Category Archives: Système

Installer Windows Seven (7) depuis une clé USB

Préparer la clé en ligne de commande [ Technique employé sur Windows 7 ]
1/ Rendre la clé USB bootable
  • Lancer une invite de commande : démarrer puis taper cmd dans le champ de recherche et valider.
  • Taper diskpart puis valider.
  • Dans la fenêtre de diskpart, taper list volume afin de savoir à quel volume correspond votre clé USB.
  • Taper select volume X (avec X le numéro de volume de la clé USB, attention à ne pas se tromper sous peine de perdre vos données !)
  • Taper clean
  • Taper create partition primary
  • Taper active
  • Taper format fs=fat32 quick
  • Taper assign

 

 

Préparer la clé avec Windows Vista

A l’aide de l’utilitaire Diskpart de Windows Vista, vous allez pouvoir nettoyer votre clé USB, créer une nouvelle partition adéquate et la formater. Votre clé USB d’au moins 4 Go ne doit plus contenir de données importantes car tout sera supprimé.

  1. Branchez votre clé USB.
  2. Cliquez sur le bouton Démarrer.
  3. Dans le champ Rechercher, saisissez la commande cmd et pressez la touche Entrée.
  4. Dans la fenêtre d’invite de commandes qui s’ouvre, saisissez la commande diskpart et pressez la touche Entrée.
  5. L’utilitaire attend alors vos instructions. Saisissez la commande list disk et appuyez sur la touche Entrée.
  6. A l’aide de la colonne Taille, identifiez votre clé USB. Notre clé USB de 4 Go possède ici le numéro 8 (Disque 8).
  7. Saisissez alors la commande select disk 8 en remplaçant 8 par le numéro que vous avez identifié précédemment. Appuyez sur la touche Entrée.
  8. Attention, la commande suivante va supprimer toutes les données et partitions existantes sur votre clé USB. Celle-ci ne doit donc plus contenir de données importantes. Saisissez alors la commande clean et pressez la touche Entrée.
  9. Saisissez la commande create partition primary puis appuyez sur la touche Entrée. Une nouvelle partition sera créée.
  10. Sélectionnez alors la nouvelle partition à l’aide de la commande select partition 1 et pressez la touche Entrée.
  11. Saisissez la commande active et pressez la touche Entrée. La partition est maintenant active.
  12. Vous pouvez maintenant formater la partition de votre clé USB. Saisissez pour cela la commande format fs=ntfs et pressez la touche Entrée. L’opération peut durer plusieurs minutes.
  13. Une fois le formatage terminé, assignez une unité à votre clé USB. Saisissez la commande assign et pressez la touche Entrée. Windows détecte alors votre clé USB.
  14. Vous pouvez alors quitter diskpart en saisissant la commande exit et en appuyant sur la touche Entrée. Fermez ensuite la fenêtre de l’invite de commandes. Votre clé USB est prête à accueillir les fichiers d’installation de Windows 7.

 

 

Rendre la clé USB amorçable

L’utilitaire Bootsect présent sur le DVD de Windows 7 et donc maintenant sur votre clé USB va vous permettre de la rendre amorçable. Attention, cette opération est dépendante de la version du système sur lequel vous êtes. Si vous souhaitez installer une version 64 bits de Windows 7, vous devrez effectuer les manipulations suivantes sur une version 64 bits de Windows XP ou Vista.

  1. Ouvrez le poste de travail ou l’Ordinateur.
  2. Identifiez la lettre de votre clé USB, ici la lettre I.
  3. Cliquez sur le bouton Démarrer (puis sur Exécuter sous XP). Saisissez la commande cmd et pressez la touche Entrée.
  4. Saisissez alors la commande x:\boot\bootsect /nt60 x: en remplaçant x par la lettre de votre clé USB notée précédemment. Dans notre cas (I) la commande devient i:\boot\bootsect /nt60 i:. Appuyez sur la touche Entrée.
  5. Votre clé est maintenant prête. Fermez la fenêtre d’invite de commandes.

 

 

 

Copier les fichiers de Windows 7 à partir d’une image ISO
Vous avez téléchargez Windows 7 et vous disposez d’une image ISO du DVD d’installation. Vous devez décompresser cette image et copier les fichiers quelle contient sur votre clé USB. Pour cela, vous aurez besoin d’un logiciel de décompression comme WinRAR, WinZIP ou encore 7-Zip.

  1. Branchez votre clé USB.
  2. Sur votre disque dur, localisez l’image ISO du DVD de Windows 7. Cliquez dessus avec le bouton droit de la souris et cliquez sur 7-Zip puis sur Extraire les fichiers.
  3. Dans la fenêtre qui s’ouvre, cliquez sur le bouton .
  4. Sélectionnez votre clé USB dans la liste puis cliquez sur OK.
  5. Cliquez sur OK.
  6. L’extraction des fichiers d’installation de Windows 7 de l’image ISO sur votre clé USB commence alors. L’opération peut durer plusieurs minutes.

 

Rendre la clé USB amorçable

L’utilitaire Bootsect présent sur le DVD de Windows 7 et donc maintenant sur votre clé USB va vous permettre de la rendre amorçable. Attention, cette opération est dépendante de la version du système sur lequel vous êtes. Si vous souhaitez installer une version 64 bits de Windows 7, vous devrez effectuer les manipulations suivantes sur une version 64 bits de Windows XP ou Vista.

  1. Ouvrez le poste de travail ou l’Ordinateur.
  2. Identifiez la lettre de votre clé USB, ici la lettre I.
  3. Cliquez sur le bouton Démarrer (puis sur Exécuter sous XP). Saisissez la commande cmd et pressez la touche Entrée.
  4. Saisissez alors la commande x:\boot\bootsect /nt60 x: en remplaçant x par la lettre de votre clé USB notée précédemment. Dans notre cas (I) la commande devient i:\boot\bootsect /nt60 i:. Appuyez sur la touche Entrée.
  5. Votre clé est maintenant prête. Fermez la fenêtre d’invite de commandes.

Astuces ZSH

Zzappers Best of ZSH Tips zzappers Tips Home Updated : 22Jan12 *N* Marks New *C* Corrected > zsh -fx # start a « clean » version of zsh (without your startup files) print $ZSH_VERSION Tips Home http://www.zsh.org/mla/ Searchable Mailing List Archive http://grml.org/zsh/zsh-lovers.html http://zsh.sourceforge.net/Doc/ Everything? *C* Zsh-Reference-Card *N* http://zshwiki.org/ man zsh man zshall zsh Zsh overview (this section) zshmisc Anything not fitting into the other sections zshexpn Zsh command and parameter expansion zshparam Zsh parameters zshoptions Zsh options zshbuiltins Zsh built-in functions zshzle Zsh command line editing zshcompwid Zsh completion widgets zshcompsys Zsh completion system zshcompctl Zsh completion control zshmodules Zsh loadable modules zshzftpsys Zsh built-in FTP client zshall Meta-man page containing all of the above /usr/share/zsh/htmldoc/zsh_toc.html Install on Linux > yum install zsh *N* Global aliases Searching and filtering my mysql database with my own utility searchdb >searchdb client1 | grep -i website1 | fmt -50 | putclip How you can simplify this using 3 zsh Global Aliases >searchdb client1 G website1 F P alias -g ND=’*(/om[1])’ # newest directory alias -g NF=’*(.om[1])’ # newest file Example of use cp NF ND # useful zsh stuff *N* ls *(.) # list just regular files *N* ls *(/) # list just directories *N* vi *(.om[1]) # vi newest file vi -p *(.om[1,3]) # open 3 newest files in tabs (gvim) vi *(m0) # re-edit all files changed today! ls *(^m0) # files NOT modified today ls -l *(m4) # list files modified exactly 4 days ago ls -l *(.m4) # list files modified exactly 4 days ago (ignore directories) vi **/main.php # where ever it is in hierarchy ls -l **/main.{php,js,css} # *N* ls fred^erick* # list all files fred* except frederick* *N* ls *.^pdf # list all but pdf’s *NN* ls (x*~x[3-5]) # list files x* except x3 to x5 ls x^[3-5]* # list files x* except x3 to x5 *N* ls **/*~*/.git/* # ignore all git subdirectories *~* matches a path *N* vi !$ # vi last parameter vi !-2:2 # second parameter of second but last command vi !$:r.php # vi last parameter but change extension to .php ^php^cfm # modify previous command (good for correcting spellos) ls *(.L0) # list pesky empty files (yes that is a zero) *N* ls -l *(L-2) # list file size less than 2 bytes *N* ls -l *(.L-20) # list file size less than 20 bytes – . ignore directories *N* ls -l *(Lk+100) # list file size greater than 100kb *N* ls -l *(Lm+2) # list file size greater than 2 mbs *N* grep -i « $1″ */*.php~libs/*~temp/*~test/* # exclude directories lib,temp,test from grep *N* grep -i « $1″ **/*.{js,php,css}~(libs|temp|temp|test)/* # exclude directories from grep *N* !! !$ (last argument) !$:h (last argument, strip one level) !$:h:h (last argument, strip two levels) !?echo vi !* (all parameters) vi !$ (last parameter) vi !^ (first previous parameter) vi !:1 (first previous parameter) vi !-2:2 (second parameter of second but last command) echo !:2-3 # echo previous parameters 2 to 3 *N* echo !:2* # echo previous parameters 2 onwards *N* echo !:2- # echo previous parameters 2 onwards omitting last *N* history # View recent commands !42 # Re-execute history command 42 # substitute previous command r oldstr=newstr !!:s/fred/joe/ # edit previous command replace first fred by joe !!:s/fred/joe/ # Note : sadly no regexp available with :s/// !!:gs/fred/joe/ # edit previous command replace all fred by joe mv Licence\ to\ Print\ Money.pdf !#^:gs/ // # rename file removing spaces ^fred^joe # edit previous command replace fred by joe ^str1^str2^:u:p # replace str1 by str2 change case and just display echo chim ^chim^&-&ney-&-&-cheree # reuse LHS !42:p also use control-R ^str1^str2^:G # replace as many as possible cd !?ls #get command and parameters of a previous ls command cd !?ls?:* #get (just) parameters of a previous ls command Generating a command from an earlier one How to recall the parameters of a previous command, on line 7 below recall the parameters of line 5 5> mv somefile1 /home/saket/stuff/books/ 6> acroread somefile.pdf 7> mv somefile2 /home/saket/stuff/books/ > mv !?saket Would bring up the whole line ready for a little editing or purist > mv !?saket?:* Would just bring up the parameters If you know the history number of the line (say 5) with desired parameters you can try > !5:s/somefile1/somefile2/ and if you dont know the history number !?saket?:s/somefile1/somefile2/ # History Substitution Summary #For CURRENT line that you are editing (the # designates current line) # Remember Tab will expand the following !#:0 command !#^ first parameter !#:1 first parameter !#:1-4 first 4 parameters !#$ last parameter !#* all parameters !#$:s/bash/zsh perform substitution on previous parameter # rename a file with a prefix cp longfilename.php backup_!#^ cp {,backup_}verylongfilename.tex # same thing mv textfile.{txt,bak} # expands to mv textfile.txt textfile.bak #For Previous Command (for comparison) !-1 repeat whole command !! repeat (shortcut) !:0 command !^ first parameter !:1 first parameter !:1-4 first 4 parameters !$ last parameter !* all parameters !!:s/bash/zsh (or ^bash^zsh) !^:t just file name of first parameter !$:h just path of last parameter !-2$:r just file name without extension of first parameter For last but one command !-2 repeat last but one command !-2^ first parameter last but one command !-2$ last parameter last but one command !-2:2 second parameter of second but last command !-2:s/bash/zsh etc For history command 42 !42 !:0 is the previous command name !^, !:2, !:3, !$ are the arguments !* is all the arguments !-2, !-3, are earlier commands !-2^, !-2:2, !-2$, !-2* are earlier parameters cd !$:h (remove file name) cat !!:t (only file name) # Convert images (foo.gif => foo.jpg): $ for i in **/*.gif; convert $i $i:r.jpg # examples of if then else conditionals *N* if [ $# -gt 0 ];then string=$*;else;string=$(getclip);fi # get parameter OR paste buffer var=133;if [[ "$var" = ]] ; then echo « $var is numeric » ;fi if [[ "$ip" = ]] then # check ip address numeric *N* if [[ "$1" == [0-9] ]] # if $1 is a digit if (( $# == 0 )); if [ $# -gt 0 ] # parameter cnt > 0 (arguments) if [[ "$url" = www* ]] # begins with www if [ "$p1" = "end" ] || [ "$p1" = "-e" ] if [[ "$p2" == *[a-zA-Z][a-zA-Z][a-zA-Z]* ]] # contains at least 3 letters if builtin cd $1 &> /dev/null ; if [[ -e /c/aam/z$1 ]] # file exists if [ $cnt -eq 1 ] if (( ${#dirs} == 1 )); then # count array length if [[ "$pwd" == *$site2* ]] print ${param:&} (last substitute) < readme.txt # < shorthand for more # Directory substitution (magic) # if you were in directory /c/inetpub/dev.somehomes.co.uk/epsystem/eppigeon/ cd dev www #would put you in parallel directory /c/inetpub/www.somehomes.co.uk/epsystem/eppigeon/ # filtering the output of a command conventionally print $(history -n -1|sed ‘s/.* //’) # ${${(z)foo}[2]} zsh filtering mechanism print ${${(z)$(history -n -1)}[-1]} print ${${(z)history[$((HISTCMD-1))]}[-1]} gvim.exe $(history -n -1 | sed « s/^[^ ]* //;s/ .*// ») print ${${(z)history[$((HISTCMD-1))]}[2]} # ls ls -ld **/*(/^F) # list any empty directories print **/*(/^F) | xargs -n1 -t rmdir #delete empty directories zargs rmdir — ./**/*(/od) 2> /dev/null # deletes empty directories ls ^x* # list all but x* #list all files without an extension ( no dot) ls *~*.*(.) # delete all directories Pictures_of_* except Pictures_of_beautiful_flowers rm -rf Pictures_of_^beautiful_flowers # selective delete *N* ls (x*~x3|x5) # list files x* except x3 and x5 ls **/fred*~*junk*/* # list all files fred* unless in a junk directory # grep, dont use egrep, grep -E is better # single quotes stop the shell,  » quotes allow shell interaction grep ‘host’ **/(*.cfm~(ctpigeonbot|env).cfm) grep -i ‘host’ **/(*.cfm~(ctpigeonbot|env).cfm)~*((#s)|/)junk*/*(.) egrep -i « ^ *mail\( » **/*.php grep « ^ *mail\( » **/*.php~*junk*/* #find all calls to mail, ignoring junk directories # grep ‘.’ dot matches one character grep b.g file # match bag big bog but not boog # grep * matches 0 , 1 or many of previous character grep « b*g » file # matches g or bg or bbbbg # grep ‘.*’ matches a string grep « b.*g » file # matches bg bag bhhg bqqqqqg etc # grep break character is \ grep ‘hello\.gif’ file grep « cat\|dog » file matches lines containing the word « cat » or the word « dog » grep « I am a \(cat\|dog\) » matches lines containing the string « I am a cat » or the string « I am a dog » grep « Fred\(eric\)\? Smith » file # grep fred or frederic # grep back references (memory) grep -i « < h\1= »"> » *.html # matches pairs of tags tel blenkinsop | grep -o « [[:alnum:][:graph:]]*@[[:alnum:][:graph:]]* » # filter just an email address from a text stream (not zsh) *N* # ls ls *.h~(fred|foo).h # same thing ls (x*~x[3-5]) # list files x* except x3 to x5 ls *[^2].php~*template* # list files with 2nd filter ls (xx|yy) # list xx or yy ls *.(jpg|gif) # list graphic files ls fred{joe,sid}.pl ls fred{09..13}.pl # range ls fred.pl# list all files fred76.pl to fred88.pl range ls fred.pl # list all files fred76.pl to fred9999*.pl etc ls {_,}fred.php # list files _fred.php fred.php ls (_|)fred.php # same effect by globbing ls *.{jpg,gif}(.N) # don’t break if one or other image type absent # FNG optionally matching a character ls -l *y{2,}.cfm # matches *y.cfm and *y2.cfm *N* ls -l *y(2|).cfm # matches *y.cfm and *y2.cfm *N* ls *{y2,y}.cfm # matches *y.cfm and *y2.cfm *N* ls *y2#.cfm # matches *y.cfm and *y2.cfm *N* ls foot(fall)#.pl # match option string fall setopt no_case_glob # set ignore case for ls etc zstyle ‘:completion:*’ matcher-list ‘m:{a-zA-Z}={A-Za-z}’ ‘r:|[._-]=* r:|=*’ ‘l:|=* r:|=*’ # case insensitive completion for cd etc *N* # globbing modifiers # :r removes the suffix from the result, # :t takes away the directory part # . means must be regular files not directories etc # *(om[1]) picks most recently modified file # (.N) no warning message if any file absent ls (#i)*.pmm # case insensitive globbing (note exact syntax) ls *(om[1]) # print the most recent file cp *(om[1]) # will complete file name ls *(.om[1]) # print the most recent file (not directory) ls -l *(Om[1]) # oldest file ls -lt **/*.tex(D.om[1,5]) # list 5 most recent files in hierarchy # list 5 most recent files in each sub-directory dirs=(  » **/*(DM/) ) eval ‘ls ${^dirs}*(ND.om[1,5])’ ls {^dev*,}/index.php(.N) # ignore directories beginning dev* ls **/index.php~dev*(/*)## # ignore subdirectories dev* multi-level vi *(.om[1]^D) # vi newest file ^D means switch off GLOB_DOTS ir ignore dot files ls *.txt(.om[1]) # ls newest *.txt file *N* ls -tld **/*(m-2)# list files modified in last 2 days in hierarchy ls *(om[1,5]) # print the 5 most recent files ls -l *(m4) # list files modified exactly 4 days ago ls -ltd *(mw3) # list files 3 weeks old ls -1ld *([1,10])# list just 10 files one per line , no directories ls *(m-1) # files modified today ls *(m0) # files modified today ls *(^m0) # files NOT modified today *N* vi *(m0) # re-edit all files changed today! ls *.{aux,dvi,log,toc} # rm latex temp files *C* rm ./*(Om[1,-11])# removes all files but the ten newest ones (delete all but last 10 files in a directory) mv *.*(^m-1) old/ # move all but today’s files to sub-directory archive older files *N* files=(${(f) »$(ls *$**) »}(.N)) # store matching files *N* ls *(n:t) # order by name strip directory ls **/*(On:t) # recursive reverse order by name, strip directory ls PHP*/**/*.php # recursive but only for subdirectories PHP* ls *.c(:r) # strip suffix ls **/*(.) # only files no directories ls -ld *(/) # list only directories #oddities [[ FOO = (#i)foo ]] # case insensitive matching fred=$((6**2 + 6)) # can do maths : > /apache/access.log # truncate a log file # arrays X=(x1 x2) # create an array print -C 1 $X # print each array element on it’s own line # 2 dimensional arrays- lookup conversion *N* typeset -A convtable convtable=(151 2 152 2 153 2 158 4 159 3 160 2 171 4 172 1 173 4) echo $convtable[158] print ${#path} # length of « path » array print ${#path[1]} # length of first element in path array print ${$( date )[2,4]} # Print words two to four of output of ’date’: array=(~/.zshenv ~/.zshrc ~/.zlogout) filelst[$(($#filelst+1))]=$x # append (push) to an array filelst+=($x) # append (push) to an array (better) files=(${(f) »$(egrepcmd1l) »} ) # push a sentence to an array (where egrepcmd1l is a global alias % print ${array:t} .zshenv .zshrc .zlogout # variable substitution somevar= »bu&^*ck » # variable with mucky characters print ${somevar//[^[:alnum:]]/_} # replace all non-alphanumerics with _ the // indicates global substitution *C* echo ${file##*/} # echo just the file name (strip the path) echo ${texfilepath%/*.*} # echo just the path (strip the file name) echo ${file%.*} # strip file extension echo $file:r # strip file extension echo ${0##*[!0-9]} # strip all but trailing digit from filename $0 echo ${(M)0%%} # strip all but trailing digit from filename file=${1/\//C:\/} # substitute / with c:/ ANYWHERE in string file=${1/#\//C:\/} # substitute / with c:/ Beginning of string file=${1/%\//C:\/} # substitute / with c:/ End of string # note # & % are using to match beginning and end wpath=${wpath//\//\\\\} # substitute Unix / with dos \ slashes *N* upath=${wpath//\\/\/} # convert backslashes to forward slashes (Dos to Unix dpath=${upath/#\/c\//c:/} # convert /c/path/ to c:\path\ *N* foo=$’bar\n\nbaz\n’ print ${foo//$’\n’} # strip out any carriage returns (some systems use \r) *N* print ${foo%%$’\n’} # strip out a trailing carriage return *N* url=’www.some.com/some_strIng-HERe’ anchortext=${${(C)url//[_-]/ }:t} # titlecase *N* echo « $anchortext » # creating a family of functions # generate hrefs from url function href{,s} { # href creates an HTML hyperlink from a URL # hrefs creates an HTML hyperlink from a URL with modified anchor text PROGNAME=`basename $0` url=`cat /dev/clipboard` if [ "$PROGNAME" = "href" ] ; then href= »$url » elif [ "$PROGNAME" = "hrefs" ] ; then anchortext=${${(C)url//[_-]/ }:t} href= »$anchortext » fi echo -n $col echo $href > /dev/clipboard | more } # create vim scratch files v1,v2 to v9 function vx{0..9} {gvim.exe c:/aax/${0/#v/} &} # # create vim scratch files va,vb to vz function vx{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,q,r,s,t,u,v,w,x,y,z} { scratchfile=${0/#v/} gvim.exe c:/aax/$scratchfile & } # regular expressions in zsh examples *N* #pcre perl regular expressions *N* zmodload zsh/pcre setopt REMATCH_PCRE var=ddddd; [[ "$var" =~ ^d+$ ]] && echo matched || echo did not match var=dddee; regexp= »^e+$ »; [[ "$var" =~ $regexp ]] && echo $regexp matched $var || echo $regexp did not match $var # decisions # cd to different drive depending on Windows login name drive=$([[ "$LOGNAME" != davidr ]] && echo ‘/o’ || echo ‘/c’) # trad way cd ${drive}/inetpub/wwwdev/www.some.co.uk/ drive=${${${LOGNAME:#davidr}:+/o}:-/c} # zsh way cd ${drive}/inetpub/wwwdev/www.some.co.uk/ # chaining two modifications # .om[1] gives newest file # cyg is a zsh function doing a path conversion gvim.exe $(echo /c/aax/*(.om[1]))(+cyg) & ### nested gvim.exe /c/aax/*(.om[1]+cyg) & #### both operations # odd stuff not necessarily zsh cp -a file1 file # -a transfer permissions etc of file1 to file2preserve # only copy if destination file exists and is older that source file [[ -e $L/config.php ]] && cp -p -update $T/config.php $L *N* # variable with variable name eval « $1=$PWD » # brilliant will change your life dirs -v # *N* cd ~5 # cd to fifth directory in directory stack cd – then type number of directory dirs -p # display recent directories *N* cp file ~1 # where 1 is first entry in pushd stack pushd +2 # cd to 3rd entry in pushd stack #zsh completion startfilename # will complete matching files anywhere in $PATH startfilename # will list matching files anywhere in $PATH vi main*~*temp* # avoid file with temp in the name cd /u/lo/li completes to /usr/local/lib #directory sizes du -sk *(/) # Inline aliases, zsh -g aliases can be anywhere in command line alias -g G=’| grep -’ alias -g L=’| less’ #this reduces a command like ls | grep foo | less #to ls G foo L # alias -g R=’ > /c/aaa/tee.txt ‘ # redirect alias -g T=’ | tee /c/aaa/tee.txt ‘ # tee alias -g F=’ | fmt -’ # format alias -g W=’ | wc -l’ # wc # # cd by .. or … or … or mv file …./. alias ‘..’='cd ..’ alias -g …=’../..’ alias -g ….=’../../..’ alias -g …..=’../../../..’ # suffix based alias alias -s jpg=’/c/program\ files/IrfanView/i_view32.exe’ now just type the image name to launch irfanview alias -s php=’c:/wamp/php/php.exe’ # now just type test.php to execute it *N* # named directories (these are a type of alias) hash -d zsh= »/usr/src/zsh » # create shortcuts to deep directories *N* cd ~zsh #magic equals vim =some_file # edits file anywhere in $PATH ls =some_file # lists file anywhere in $PATH #magic ** (recursion) vim **/some_file # edits file under under current dir # modifying more than one file (multios) # writes ls results to file1 & file2 appends to filec ls > file1 > file2 >> file3 | wc # multi-io myscript >&1 >output.txt # log a script output #Redirection to file as well as send on to pipe: make install > /tmp/logfile | grep -i error function g{0..9} { gmark $0 $* } # declaring multiple functions # zmv « programmable rename » autoload -U zmv # Replace spaces in filenames with a underline zmv ‘* *’ ‘$f:gs/ /_’ zmv ‘(* *)’ ‘${1// /}’ zmv -Q « (**/)(* *)(D) » « \$1\${2// /_} » # Change the suffix from *.sh to *.pl zmv -W ‘*.sh’ ‘*.pl’ # lowercase/uppercase all files/directories $ zmv ‘(*)’ ‘${(L)1}’ # lowercase $ zmv ‘(*)’ ‘${(U)1}’ # uppercase #Wonderful zftp (write ftp scripts as though shell) # init (could be in .zshenv etc) autoload -U zfinit zfinit zfparams www.someweb.co.uk myuserid mypassword zfopen zfcd tips zfls -l zshtips.html zfput zshtips.html zfls -l zshtips.html # replace every occurence of a file (zsh and bash) for f in */include/dbcommon.php; do;cp dbcommon.php $f; done # create a clone of a file, modifying it on the fly *N* for i in {3,4}; sed s/flag=2/flag=$i/ fred.txt > fred$i.txt for i in {1..9}; sed s/flag=2/flag=$i/ fred.txt > fred$i.txt # loop a command *N* while true; do echo « infinite loop »; sleep 5; done # using vared vared -p « choose 1-3 :  » -c ans case $ans in 1|a) sdba $key;; 2|f) sdbf $key;; 3|i) sdbi $key;; *) echo « wrong answer $ans\n » ;; esac # the powerful select PROMPT3= »Choose File :  » select f in $(ls **/*.tex |egrep -i « ${param}[^/]*.tex ») do if [[ "$REPLY" = q ]] then break elif [[ -n "$f" ]]; then gvim $f fi done # multiple script commands on same line if [ $# -gt 0 ];then string=$*;else;string=$(getclip);fi # editing a variable (You must try this) vared PATH bindkey -v # vi mode line editting bindkey -M viins ‘^O’ copy-prev-shell-word bindkey ‘^L’ push-line # push current command into a buffer, allows you to do another command then returns to previous command # configure F7 to output a command bindkey -s ‘^v’ « ls -l\n » # configure F7 to output ‘ls -l’ bindkey -s « ^[[18~" "ls -l\n" # You must actually type Control-v F7 this is what it looks like on my system : # Prompt at end of command line RPROMPT="[%t] » (display the time) # colo(u)red prompt fg_light_red=$’%{\e[1;31m%}' PS3="$fg_light_red Select file : " # print fred in blue color print '\e[1;34m fred' # color module autoload colors ; colors print "$bg[cyan]$fg[blue]Welcome to man zsh-lovers » >> $TTY curl -u userid:password -d status= » updating twitter with from curl  » http://twitter.com/statuses/update.xml # my .zshenv *N* autoload -U compinit compinit autoload edit-command-line zle -N edit-command-line bindkey ‘\ee’ edit-command-line VISUAL=’/bin/vim’ EDITOR=’/bin/vim textify a phrase to create an image name s=’Fred Goat Dog’ print ${(L)s:gs/ /-/}.jpg or print ${(L)s// /-}.jpg and to de-textify an image foo=fred-goat-dog.jpg echo ${(C)foo:gs/-/ /:r} or print ${${(Cs:-:):-fred-goat-dog.jpg}%.*} #new # » read a file into a variable var= »$( Zsh Syntax Aide-Memoire *N* vi *(om[1]) # edit newest file gvim -p *(m0) # all files today mv *.*(^m-1) old/ # move all but todays files to sub-directory vi -p *(.om[1,3]) # open 3 newest files in tabs (gvim) ls *(^m0) # files NOT modified today ls -l *(m4) # list files modified exactly 4 days ago ls *.{jpg,gif}(.N) # don’t break if one or other image type absent mv !?main # recall previous command containing the string main mv !?main?:* # recall just parameters of previous command containing the string main ls -l **/main.{php,js,css} # *N* ls (x*~x[3-5]) # list files x* except x3 to x5 ls **/*~*/.git/* # ignore all git subdirectories *~* matches a path *N* # zsh menu echo « enter 0-2,a » read ans ; # read in a parameter case « $ans » in 0|${prog}0) cd « $(cat /c/aam/${prog}0) » ;; 1|${prog}1) cd « $(cat /c/aam/${prog}1) » ;; 2|${prog}9) cd « $(cat /c/aam/${prog}9) » ;; a|${prog}l) cd « $(cat /c/aam/${prog}a) » ;; **) echo « wrong number $ans\n » ;; esac Sources newsgroup gmane.comp.shells.zsh.user, masterzen Everything here is Simple zsh visit the above newsgroup for the Sick stuff Upload this page (use yy@ » on following line, to invoke upload zftp script)!! :!zshtipsftp <>

Cours SSH

Le protocole SSH
SSH est l’abréviation de Secure Shell, qui est à la fois un programme informatique et un protocole de communication sécurisé.
Le protocole de connexion impose un échange de clé de chiffrement en début de connexion. Par la suite toutes les trames sont chiffrées. Il devient donc impossible d’utiliser un sniffer pour voir ce que fait l’utilisateur.
Le protocole SSH a été conçu avec l’objectif de remplacer les différents programmes rlogin,telnet et
rsh.
Le protocole SSH existe en deux versions majeures : la version 1.0 et la version 2.0.
La première version permet de se connecter à distance à un ordinateur afin d’obtenir un shell ou ligne de commande. Cette version souffrait néanmoins de problèmes de sécurité dans la vérification
de l’intégrité des données envoyées ou reçues, la rendant vulnérable à des attaques actives. En outre,
cette version implémentait un systeme de transmission de fichiers sommaires, et du port tunneling.
La version 2 est actuellement encore à l’état de draft, mais est déjà largement utilisée à travers le
monde. Cette version est beaucoup plus sûre cryptographiquement, et possède en plus un protocole
de transfert de fichiers complet.

Fonctionnement des clefs

Clefs symétriques
Le système est simple: une seule clef, qui permet à la fois de crypter des données et de le décrypter.
Un inconvénient notable : la clef doit être diffusée à tous les correspondants qui veulent pouvoir
chiffrer/déchiffrer les données. Et donc une clef doit être générée pour chaque intervenant différent.

Clefs asymétriques
Le fonctionnement est plus complexe. On travaille ici avec des paires de clefs, une publique, et une privée.
La clef publique sert pour le chiffrement des données, et la clef privée pour le déchiffrement (cela marche dans l’autre sens également).
Bien sûr l’algorithme utilisé pour générer les clefs privées et publiques doit être suffisamment
puissant pour être sûr : RSA1, ou mieux aujourd’hui, DSA et RSA2 (appelé communément RSA).

Chiffrage
Imaginons Alice, qui veut recevoir un message crypté à Bob.
Alice va générer une paire de clefs, et va envoyer sa clef publique à Bob.
Bob va chiffrer ses données avec cette clef publique, et envoyer les données chiffrées à Alice.
Alice va alors pouvoir déchiffrer les données avec sa clef privée, et elle seule peut le faire. C’est pourquoi la clef privée doit rester secrète pour Alice.


Authentification
Cependant, ceci ne permet pas à Alice d’être sûre que le message provient bien de Bob; si quelqu’un
d’autre a pu avoir la clef publique, alors il a pu chiffrer des données de la même façon.
Pour l’authentification, il faut alors que Bob lui aussi génère une paire de clefs.
Le mécanisme est alors le suivant :

1) Alice envoie sa clef publique KApub à Bob.
2) Bob va crypter un message une première fois avec sa clef privée.
3) Puis il va crypter ce message une deuxième fois avec la clef publique d’Alice KApub.
4) Il va ensuite envoyer à Alice, le message doublement crypté, et sa clef publique KBpub.
5) Alice va alors déchiffrer le message une première fois avec sa clef privée, elle est la seule à pouvoir le faire.
6) Puis elle va déchiffrer le message une deuxième fois avec la clef publique de Bob, KBpub.
7) Si le message est lisible, alors c’est qu’il sans aucun doute de Bob.

C’est le mécanisme d’authentification utilisé par la plupart des systèmes sécurisés aujourd’hui,
notamment les VPNs IPSEC, SSH, …
Les avantages sont clairs : une clef publique peut être divulguée en toute sécurité, elle ne permettra
pas à quiconque de pouvoir usurper une identité ou de pouvoir déchiffrer des données qui ne lui
sont pas destinées.

Taille des clefs
Aucun des deux système n’est fiable : on peut effectivement essayer toutes les clefs possibles sur un
message afin d’obtenir un résultat, et obtenir les données déchiffrées et même connaître la clef.
Cependant, les algorithmes sont prévus pour pouvoir être facilement utilisés pour chiffrer, mais
beaucoup plus difficile à déchiffrer. Ainsi le temps de calcul avec une mauvaise clef est très
important.
Et surtout, il est exponentiel avec la taille de la clef.
Ainsi, 128bits -> 2^128 possibilités.
Il faut noter cependant que les clefs asymétriques sont beaucoup plus faciles à « casser » : de la
nature de l’algorithme, une factorisation permet de limiter le nombre d’essais.
Mais si le processus de factorisation est aisé sur quelques bits, sa difficulté augmente elle aussi
exponentiellement avec la taille de la clef.
Ainsi aujourd’hui il faut des ressources démesurées pour craquer des clefs de 512 bits. Aussi pour
1024 bits ou plus, il faut des centaines d’ordinateurs pour réussir une telle opération.
Comme la puissance des processeurs évolue aujourd’hui exponentiellement elle aussi, il est
conseillé de travailler en 2048 bits voire 4096.

A noter aussi que l’on est toujours dépendant de l’algorithme de calcul, et que c’est l’impossibilité à
ce jour d’avoir un algorithme de factorisation efficace qui permet de garder ces clefs sûres.
Il faut voir aussi que souvent lorsque que le cryptage est utilisé dans les tunnels, une renégociation
des clefs est effectuée régulièrement afin de se protéger.
Enfin, il faut donc noter la différence de sûreté de chiffrement entre des clefs symétriques et
asymétriques, en fonction de la taille des clefs.


Utilisation de SSH
La première utilisation de SSH est de pouvoir exécuter un programme distant, le plus souvent un
shell utilisateur, comme RSH, mais avec des fonctions avancées d’authentification et de cryptage.
Mais le protocole implémente des fonctions beaucoup plus importantes :

1. Transfert de fichiers (via scp, ou sftp)
2. Redirection de ports TCP
3. Proxy socks
4. Execution de programmes

Sécurité
Le protocole SSH est fortement sécurisé par défaut sur la plupart des distributions. Cependant, il
n’empêche pas les failles de sécurités !
Les implémentations de SSH peuvent contenir de failles, notamment openssh (serveur SSH libre)
qui a possédé en son temps (jusqu’à la version 3.3) une faille grave, un segmentation fault qui
donnait un accès shell root.
De même, lors de l’authentification par login/pass, rien n’empêche la connexion sur un compte avec
un mot de passe faible; on en revient aux problèmes de tous les protocoles, à moins de se restreindre
aux authentification par clefs uniquement.
Il faut aussi penser que donner un accès ssh à utilisateur lui permet, sans changement de
configuration, d’effectuer de la redirection de port, et par exemple de transformer le serveur en
bouncer.


Cours sécurité & Système d’exploitation

1 - Pré-requis
1.1 -  Couches OSI
1.1.1 -   Intérêt
OSI (Open Systems Interconnection, « modèle de référence d’interconnexion de systèmes
ouverts »)
– offrir une base commune à la description de tout réseau informatique
– séparation des services, une couche s’appuie sur une autre
1.1.2 -   Structure théorique & concrète
Structure théorique
Logiciel         7
Application    6
Présentation
5
Session
4
Transport
OS & Drivers
Dangers
3
Réseau
2
Liaison
1
Physique
Matériel
Structure concrète
Aucune correspondance réelle des 7 couches dans la réalité :
– modèle trop difficile à implémenter
– le modèle TCP/IP s’est imposé de lui même (implémentations déjà présentes).
5-6-7
Application
HTTP, FTP, DNS, IRC…
4
Transport
TCP, UDP
3
Réseau
IP
2
Liaison
Ethernet, Token Ring…
1
Physique
Techniques de codages

1.2 -  Applications
1.2.1 -   Communication Réseau

• Driver : communique avec le matériel (carte réseau, wi-fi, usb…)

• Couches réseaux : partie intégrante du noyau, ouverture de sockets, …

• Protocole : langage spécifique au besoin de l’application (HTTP, SMTP…)
1.2.2 -   Accès au Système

• Danger d’une application client, et de son accès au système (fichiers, autres programmes)
• Quasiment rien n’est faisable sans application
• Communication entre applications (un programme peut en lancer un autre, en diriger un autre)
2 - Système d’exploitation, Programmes, Utilisateurs & Droits
2.1 -  Objectif d’un OS

Objectifs principaux :
• Gestion du / Accès au matériel : CPU, mémoire, périphériques divers
• Lancement et gestion des programmes (processus)

Différencier le noyau et les applications:
• Il existe des centaines de noyaux différents : celui de Microsoft, linux, BSD, Symbian, Apple, Hurd…
• Les applications peuvent être portables d’un OS à l’autre.
En général des applications sont installées en même temps que l’OS : on parle de distribution (debian, mandrake, red hat, … MS Windows peut être vu comme une distribution).
Pour certaines applications très proches du système, la différenciation est difficile.

2.2 -  Kernel space / User space
• Le « Kernel space » : l’espace noyau
• Critique au fonctionnement du système
• On y trouve les pilotes pour le matériel, pour les systèmes de fichier, les couches réseau…
• Le « crash » d’un programme dans le kernel space est généralement fatal (voir HURD)
• Le « User space » : l’espace utilisateur
• Logiciels divers : outils, bureau, jeux…
• Le « crash » d’un programme dans le user space n’est pas fatal – sauf exceptions (verrous, conso CPU, …)
Bien sûr il y a besoin d’une communication entre l’espace noyau et l’espace utilisateur, via des librairies
standard : pour récupérer l’image d’une webcam, produire du son, ouvrir une socket…

2.3 -  Gestion des programmes / Scheduler
Il n’y a en réalité qu’un seul processeur sur une machine, et qu’une seule plage mémoire globale.
C’est donc à l’OS de gérer le multitâche : l’exécution de plusieurs processus qui fonctionnent en
simultané, et le partage des accès à la mémoire, aux systèmes de fichiers, au matériel.
C’est le rôle du « Scheduler » (ordonnanceur), qui exécute en réalité toutes les processus les un après
les autres, plusieurs fois par secondes.

2.3.1 - Processus
Un processus est un programme exécuté. Il a son environnement propre (variables, utilisateur, verrous,
zone mémoire bien à lui,…).

Il peut avoir une priorité : souvent on attribue une priorité plus importante aux tâches interactives pour
donner une meilleure impression pour le temps de réponse.

Démons et services
Certains processus sont destinés à être exécuté sans aucune interaction de utilisateur, on les appelle en
général « services » (sous Windows) ou « démons » (sous linux). On parle aussi de tâches qui
fonctionnent « en arrière plan ».
On retrouve dans cette catégorie la plupart des serveurs connus : apache (serveur web), samba (serveur
de partage de fichier), …
Ces démons sont généralement contrôlés indirectement par :
• des fichiers de configuration (nécéssite un redémarrage)
• des appels par des signaux

Initialisation du système
Lorsque l’OS démarre, il faut bien lancer toutes les tâches vitales au fonctionnement. Sous linux, il
s’appelle « init ». Il va lancer tous les démons / services utiles, en fonction d’une configuration définie.

Attributs
Un processus a toujours un identifiant unique: le PID (process identifier). C’est un numéro unique,
incrémental.
Il a aussi toujours un parent, son ppid (parent process identifier). C’est en fait le PID du processus qui
l’a éxécuté. Si le parent est arrivé en fin d’éxécution, alors c’est le processus init, qui a toujours le PID 1,
qui devient son parent par défaut. C’est le cas général des démons.

Signaux
On peux généralement communiquer de façon basique avec un processus par des signaux.
Les signaux les plus connus sont TERM et KILL, qui demandent au processus de se terminer.

Verrous
Lorsque plusieurs processus veulent accéder à une même ressource (ex: fichier, disque), il est
nécessaire d’avoir des verrous (locks).
2.4 -  Notion d’utilisateur
Définition

Un utilisateur sur un système d’exploitation peut correspondre à une personne, mais pas forcément.
Notamment, sous les environnements *nix, il existe des dizaines d’utilisateurs ne correspondant pas à
une personne physique.
Un utilisateur est avant tout un login (identifiant unique), et un password (mot de passe). En général lui est associé un UID (identifiant utilisateur), qui est numérique.
On a aussi, souvent la notion de groupe, avec un nom, et un GID (identifiant groupe), numérique lui
aussi. Un utilisateur peut appartenir à un ou plusieurs groupes, pour faciliter la gestion.

Utilité

• Propriété : sur un système, les fichiers et les processus appartiennent forcément à un utilisateur.

• Droits : on peut donner des droits / restrictions à un utilisateur ou à un groupe

• Logging : sur un système surveillé, on peut savoir quel utilisateur se connecte, lance tel ou tel processus…

 

2.5 -  Système de fichier

Un support de stockage n’est ni plus ni moins qu’une suite d’octets, linéraire. Un système de fichier est un schéma d’organisation permettant de gérer des fichiers et arborescences sur cet espace.
Il en existe là aussi plusieurs : FAT, EXT, NTFS, XFS, REISERFS, le futur WINFS, … Chacun a ses propriétés : +/- grande gestion des droits sur chaque fichier, intégrité des données,
rapidité, fragmentation…

2.6 -  Authentification et Domaines

Un utilisateur existe sur un système. Cependant, il est assez courant aujourd’hui d’avoir l’existence d’un
utilisateur virtuellement sur tout un réseau. Dans ce cas, on parle généralement de domaine, avec un
contrôleur de domaine qui va:
• contenir la base de donnée des utilisateurs
• gérer son authentification (par mot de passe ou autre)
• gérer son profile (informations supplémentaires, droits).
C’est l’objectif des technologies LDAP, Active Directory, Radius… En conséquence, un système ne peut
être séparé du réseau, et au lieu d’effectuer lui même l’authentification, il va en faire la demande au
contrôleur.
Malgré tout, pour la plupart des postes indépendants,  la base de donnée est locale.
2.7 -  Démons courants

Il existe des démons que l’on trouve sur quasiment tous les systèmes, ne seraient-ce que les
gestionnaires de mémoire.
Sous linux, il y a la présence quasi systématique d’un serveur de mail, pour des raisons historiques. Les
plus courants sont Sendmail, Postfix, Exim.
Dès qu’il s’agit d’un système à vocation de serveur, on retrouve souvent ces différents programmes :
apache
serveur HTTP
postfix
serveur SMTP
sendmail
exim
courier
serveur IMAP, POP
cyrus
mysqld
serveur de base de donnée
postmaster
proftpd
serveur FTP
pureftpd
2.8 -  Chroot / Jail
Le fait qu’un processus appartienne à un utilisateur, et donc qu’il soit lancé sous son nom, permet de le
limiter aux droits de cet utilisateur. Ainsi si ce programme devient un risque pour le système, il ne pourra pas faire plus de mal que ce même utilisateur.
D’où l’intérêt d’exécuter le minimum de programmes en tant que « super utilisateur » (administrateur 
sous windows, root sous *nix).

Cependant pour plus de sécurité, il existe une solution qui s’appelle « chroot ». Elle change virtuellement et pour un processus sa vision de la racine du système de fichier ( / ). Bien sûr cela nécessite d’avoir une arborescence système en double, spécifique à ce processus. Mais cela donne
l’assurance que le processus n’aura pas accès à d’autres parties du disque.