Alors voila... je fais actuellement un programme de gestion de serveur.  
J'utilise Serv-U comme serveur FTP, et je voudrais a partir de mon programe gérer la liste des utilisateurs (droits d'access au fichiers... mot de passe). Et je me demande s'il est possible de connaitre l'algorithe de cryptage des mot de passe Serv-U, afin que je puisse écrire la fonction dans mon programme afin que je crypte, décrypte les mot de passe ?
J'ai étudidié un peu les mot de passe crypté, et j'ai remarqué qu'il y avait plusieurs possibilités pour un même mot de passe. Par exemple :

 
J'ai réussi a avoir la DLL contenant les fonctions de cryptage... est-il possible de connaitre l'algo a partir de la ? La desassembler m'a-t-on dit... mais j'ai aucune connaissance en ASM, ce qui ne me permet pas de faire cela... qq saurait il le faire ?  
 
voila... je peux fournir la DLL si qq se sent capable de faire cela.. ou alors si qq veut bien m'expliquer comment faire ? peut etre aussi que la liste des codes pourra guider qq sur la bonne voie... merci d'avance pour votre aide

regarder la fonction desassembler, ca peut etre un peu compliquer
 
deja:  
1/ comment s'appelle la DLL en question ?
2/ comment s'appelle la fonction de cryptage/decryptage?  
3/ c'est bizarre que tu puisse crypter un password de plusieurs facon differentes ... enfin why not.
4/essaye de comparer les cryptages avec d'autre algo connu ?
 
renseigne toi sur la crypto un peu plus... google that.

alors, la DLL s'appelle PASSWD.DLL, c'est une DLL de Serv-U. La fonction pour crypter une chaine s'appelle char * MakePassword(const * char ClearText)
 
Il n'y a apparement pas de fonction de décryptage, mais j'ose esperer qu'en connaissant l'algo de cryptage, je sache faire l'algo de décryptage... finalement, comparer avec des algos connus... j'ai deja pas mal cherché, mais a mon avis, Serv-U a essayé d'utiliser son propre algo (ou une combinaison de plusieurs algos...)
 
bref j'suis un peu dans les choux la
 
la DLL est dispo ici : ftp://ftp.cat-soft.com/add-ons/ChgUser/Source.zip merci d'avance

non a priori tu ne pourras pas faire d'algo de decryptage.
de nombreux algo ne sont pas reversible (cf MD5).
 
par contre tu peux tenter de forcer l'algo. et trouver un password qui convienne. (pour ca tu utilise la dll dasn un prog C, et tu genere enormement de password, que tu encrypte et compare a celui initial).

j'avais pour idée que les 2 premiers chars seraient une clé... et les autres, des valeurs, en hexa... mais de la a savoir qui sert a quoi...

 
Bin y'a ptet tout simplement pas possibilité de decripter ?

j'ai trouvé l'algo en VBScript... j'vais essayer de traduire ça en C. Merci a vous pour avoir répondu

il est long cet algo, fait un copy paste peut etre que ca ressemble a qq chose de connu

<?xml version="1.0"?>
<component>
 
<?component error="true" debug="false"?>
 
<registration
 description="MD5"
 progid="MD5.WSC"
 version="1.00"
 classid="{cab3f5a1-775f-4da5-851f-d11c96a1f024}"
/>
 
<public>
 <method name="calcMD5">
  <PARAMETER name="sInput"/>
 </method>
</public>
 
<script language="JScript">
<![CDATA[
 
 
// ---------------------------------------------------------------------------------
// MD5 Windows Scripting Component wrapper definition
 
 var description = new MD5;
 function MD5()
 {
  this.calcMD5 = calcMD5;
 }
// ---------------------------------------------------------------------------------
 
 
// ---------------------------------------------------------------------------------
// Legal notice taken from Google's cache of http://pajhome.org.uk/site/legal.html
 
 /*
 The following is distributed under the GNU Lesser General Public License, which
 also allows linking into proprietory programs, under certain circumstances.
 
 GNU LGPL described here: http://www.gnu.org/copyleft/lgpl.html
 
 The JavaScript code implementing the algorithm is derived from the C code in
 RFC 1321 and is covered by the following copyright:  
 
 ---------------------------------------------------------------------------------
 Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved.  
 License to copy and use this software is granted provided that it is identified  
 as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material  
 mentioning or referencing this software or this function.
 
 License is also granted to make and use derivative works provided that such works
 are identified as "derived from the RSA Data Security, Inc. MD5 Message-Digest  
 Algorithm" in all material mentioning or referencing the derived work.
 
 RSA Data Security, Inc. makes no representations concerning either the  
 merchantability of this software or the suitability of this software for any  
 particular purpose. It is provided "as is" without express or implied warranty  
 of any kind.
 
 These notices must be retained in any copies of any part of this documentation  
 and/or software.  
 ---------------------------------------------------------------------------------
 
 This copyright does not prohibit distribution of the JavaScript code under LGPL.
 */
// ---------------------------------------------------------------------------------
 
 
// ---------------------------------------------------------------------------------
// MD5 code taken from Google's cache of http://pajhome.org.uk/crypt/md5/md5src.html
 
 /*
  * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
  * Digest Algorithm, as defined in RFC 1321.
  * Copyright (C) Paul Johnston 1999 - 2002.
  * Code also contributed by Greg Holt
  * See http://pajhome.org.uk/site/legal.html for details. (also copied above)
  */
 
 /*
  * Convert a 32-bit number to a hex string with ls-byte first
  */
 var hex_chr = "0123456789ABCDEF"; // changed to use upper-case hex chars
 //var hex_chr = "0123456789abcdef"; // original lower-case hex chars
 function rhex(num)
 {
  var str = "";
  for(var j = 0; j <= 3; j++)
    str += hex_chr.charAt((num >> (j * 8 + 4)) & 0x0F) +
           hex_chr.charAt((num >> (j * 8)) & 0x0F);
  return str;
 }
 
 /*
  * Convert a string to a sequence of 16-word blocks, stored as an array.
  * Append padding bits and the length, as described in the MD5 standard.
  */
 function str2blks_MD5(str)
 {
  var nblk = ((str.length + 8) >> 6) + 1; // number of 16-word blocks
  var blks = new Array(nblk * 16);
  for(var i = 0; i < nblk * 16; i++) blks[i] = 0;
  for(var i = 0; i < str.length; i++)
   blks[i >> 2] |= str.charCodeAt(i) << ((i % 4) * 8);
  blks[i >> 2] |= 0x80 << ((i % 4) * 8);
  blks[nblk * 16 - 2] = str.length * 8;
  return blks;
 }
 
 /*
  * Add integers, wrapping at 2^32. This uses 16-bit operations internally
  * to work around bugs in some JS interpreters.
  */
 function safe_add(x, y)
 {
  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
  return (msw << 16) | (lsw & 0xFFFF);
 }
 
 /*
  * Bitwise rotate a 32-bit number to the left
  */
 function rol(num, cnt)
 {
  return (num << cnt) | (num >>> (32 - cnt));
 }
 
 /*
  * These functions implement the basic operation for each round of the
  * algorithm.
  */
 function cmn(q, a, b, x, s, t)
 {
  return safe_add(rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
 }
 function ff(a, b, c, d, x, s, t)
 {
  return cmn((b & c) | ((~b) & d), a, b, x, s, t);
 }
 function gg(a, b, c, d, x, s, t)
 {
  return cmn((b & d) | (c & (~d)), a, b, x, s, t);
 }
 function hh(a, b, c, d, x, s, t)
 {
  return cmn(b ^ c ^ d, a, b, x, s, t);
 }
 function ii(a, b, c, d, x, s, t)
 {
  return cmn(c ^ (b | (~d)), a, b, x, s, t);
 }
 
 /*
  * Take a string and return the hex representation of its MD5.
  */
 function calcMD5(sInput)
 {
  var x = str2blks_MD5(sInput);
  var a =  1732584193;
  var b = -271733879;
  var c = -1732584194;
  var d =  271733878;
 
  for(i = 0; i < x.length; i += 16)
  {
     var olda = a;
     var oldb = b;
     var oldc = c;
     var oldd = d;
 
     a = ff(a, b, c, d, x[i+ 0], 7 , -680876936);
     d = ff(d, a, b, c, x[i+ 1], 12, -389564586);
     c = ff(c, d, a, b, x[i+ 2], 17,  606105819);
     b = ff(b, c, d, a, x[i+ 3], 22, -1044525330);
     a = ff(a, b, c, d, x[i+ 4], 7 , -176418897);
     d = ff(d, a, b, c, x[i+ 5], 12,  1200080426);
     c = ff(c, d, a, b, x[i+ 6], 17, -1473231341);
     b = ff(b, c, d, a, x[i+ 7], 22, -45705983);
     a = ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
     d = ff(d, a, b, c, x[i+ 9], 12, -1958414417);
     c = ff(c, d, a, b, x[i+10], 17, -42063);
     b = ff(b, c, d, a, x[i+11], 22, -1990404162);
     a = ff(a, b, c, d, x[i+12], 7 ,  1804603682);
     d = ff(d, a, b, c, x[i+13], 12, -40341101);
     c = ff(c, d, a, b, x[i+14], 17, -1502002290);
     b = ff(b, c, d, a, x[i+15], 22,  1236535329);
 
     a = gg(a, b, c, d, x[i+ 1], 5 , -165796510);
     d = gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
     c = gg(c, d, a, b, x[i+11], 14,  643717713);
     b = gg(b, c, d, a, x[i+ 0], 20, -373897302);
     a = gg(a, b, c, d, x[i+ 5], 5 , -701558691);
     d = gg(d, a, b, c, x[i+10], 9 ,  38016083);
     c = gg(c, d, a, b, x[i+15], 14, -660478335);
     b = gg(b, c, d, a, x[i+ 4], 20, -405537848);
     a = gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
     d = gg(d, a, b, c, x[i+14], 9 , -1019803690);
     c = gg(c, d, a, b, x[i+ 3], 14, -187363961);
     b = gg(b, c, d, a, x[i+ 8], 20,  1163531501);
     a = gg(a, b, c, d, x[i+13], 5 , -1444681467);
     d = gg(d, a, b, c, x[i+ 2], 9 , -51403784);
     c = gg(c, d, a, b, x[i+ 7], 14,  1735328473);
     b = gg(b, c, d, a, x[i+12], 20, -1926607734);
 
     a = hh(a, b, c, d, x[i+ 5], 4 , -378558);
     d = hh(d, a, b, c, x[i+ 8], 11, -2022574463);
     c = hh(c, d, a, b, x[i+11], 16,  1839030562);
     b = hh(b, c, d, a, x[i+14], 23, -35309556);
     a = hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
     d = hh(d, a, b, c, x[i+ 4], 11,  1272893353);
     c = hh(c, d, a, b, x[i+ 7], 16, -155497632);
     b = hh(b, c, d, a, x[i+10], 23, -1094730640);
     a = hh(a, b, c, d, x[i+13], 4 ,  681279174);
     d = hh(d, a, b, c, x[i+ 0], 11, -358537222);
     c = hh(c, d, a, b, x[i+ 3], 16, -722521979);
     b = hh(b, c, d, a, x[i+ 6], 23,  76029189);
     a = hh(a, b, c, d, x[i+ 9], 4 , -640364487);
     d = hh(d, a, b, c, x[i+12], 11, -421815835);
     c = hh(c, d, a, b, x[i+15], 16,  530742520);
     b = hh(b, c, d, a, x[i+ 2], 23, -995338651);
 
     a = ii(a, b, c, d, x[i+ 0], 6 , -198630844);
     d = ii(d, a, b, c, x[i+ 7], 10,  1126891415);
     c = ii(c, d, a, b, x[i+14], 15, -1416354905);
     b = ii(b, c, d, a, x[i+ 5], 21, -57434055);
     a = ii(a, b, c, d, x[i+12], 6 ,  1700485571);
     d = ii(d, a, b, c, x[i+ 3], 10, -1894986606);
     c = ii(c, d, a, b, x[i+10], 15, -1051523);
     b = ii(b, c, d, a, x[i+ 1], 21, -2054922799);
     a = ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
     d = ii(d, a, b, c, x[i+15], 10, -30611744);
     c = ii(c, d, a, b, x[i+ 6], 15, -1560198380);
     b = ii(b, c, d, a, x[i+13], 21,  1309151649);
     a = ii(a, b, c, d, x[i+ 4], 6 , -145523070);
     d = ii(d, a, b, c, x[i+11], 10, -1120210379);
     c = ii(c, d, a, b, x[i+ 2], 15,  718787259);
     b = ii(b, c, d, a, x[i+ 9], 21, -343485551);
 
     a = safe_add(a, olda);
     b = safe_add(b, oldb);
     c = safe_add(c, oldc);
     d = safe_add(d, oldd);
  }
  return rhex(a) + rhex(b) + rhex(c) + rhex(d);
 }
]]>
</script>
 
</component>
 
Voila... j'avoue que j'ai du mal a traduire, mais bon ^^

c'est le code du md5 -> pas possible de recupéré les donnée...

 
Ca c'est du cryptage MD5.
Déjà, MD5 n'est pas un algo de cryptage, c'est un algo de signature. Une espèce de grosse fonction qui te hashe un fichier de taille quelconque en une signature de 32 octets.
Cet algo a été considéré comme assez robuste pour servir d'authentification. Quand tu entres un mot de passe, il est signé par l'algo et le résultat est comparé avec la signature déjà enregistrée. Mais cet algo n'est pas réversible (un peu comme dans la fonction "y=ax2 + bx + c" c'est facile de trouver "y" en fonction de "x" mais très difficile de trouver "x" en fonction de "y" ).
 
Maintenant, si tu veux quand-même essayer de l'inverser, t'as les sources md5 disponibles assez facilement
http://www.cr0.net:8040/code/crypto/md5/md5.c

l'inverser non, par contre, je cherche a le traduire en C, mais j'avoue que j'ai du mal, la synthaxe est assez bizzare

bha tu as le code juste au dessus...

c'est exactement le meme ?

bha oui, md5

j'ai compris en fait, le fait qu'une meme chaine puisse etre encodée de plusieurs façons différente ça s'explique comme ça :
les 2 premiers chars, sont des chars choisi au hasard, et en fait le MD5 calculé, est le MD5 des deux char suivi du mot de passe... voila voila, merci de votre aide

Il faut préciser que l'ajout de ces deux chars permet d'éviter de trouver trop facilement le mot de passe en multipliant par 32*32 = 1024, le nombre de possibilités de codage d'un même mot de passe ("maison" peut se retrouver hasher de 1024 manières, ce qui ralentit la découverte de ce mot).
 
Les mots de passe sous unix sont cryptés dans un fichier opasswd selon le même principe, non ?

je suis pas au courrant