Voici la solution en alphanumérique du 2em pb . le message est réparti entre 3 personnes
Il y a donc !3=6 permutations pour décoder. Voyez l' exemple ci dessous :
Code : Tout sélectionner
Macro _q_t_
"
EndMacro
Macro _n (__n)
_q_t_#__n#=_q_t_+Str(__n)+" "
EndMacro
Macro _s (__S)
_q_t_#__S#=_q_t_+__S+" "
EndMacro
Procedure.l STRINGtoBSTR(String$)
EnableExplicit
Protected Result = 0
CompilerIf #PB_Compiler_Unicode
Result = SysAllocString_(@String$)
CompilerElse
Protected *buff = AllocateMemory(Len(String$)*2 + 4);; modif PAPIPP pour ^étre conforme au BSTR
If *buff
PokeS(*buff, String$, -1, #PB_Unicode)
Result = SysAllocString_(*buff)
FreeMemory(*buff)
EndIf
CompilerEndIf
ProcedureReturn Result
DisableExplicit
EndProcedure
Procedure.s KEYGEN(LONG_CAR, DEB_RANDOM, deb_car,fin_car)
EnableExplicit
; Générateur de clé aléatoire :
; Long_car longueur de la clé si possible de même longueur que le message à crypter
; DEN_RANDOM SI zero pas de randomseed
; SI <>0 randomseed car RandomSeed() n'est utile que lorsque l'objectif est de générer des nombres aléatoires
; dans le même ordre à chaque fois que le programme est exécuté.
; deb_car N° ASCII du début de table des caractère ASCII de 0 à 255 mais 0 est dans tous les cas éléliminé et remplacé par 1
; fin_car N° ASCII de la fin de la table exemple pour être sûr d'avoir des caractère visibles et éditable deb_car =32 et fin_car=126
; pour les valeurs numériques 1234567890 donnez deb_car = 48 et fin_car =57
; sortie en UNICODE pour générer par la suite une clé avec une structure BSTR car XOR peut générer chr(0)
; et donc rendre toutes les instructions PB sur string pratiquement inutilisables.
Define i, length , cle$ ,nb
CompilerIf #PB_Compiler_Unicode
;;;; univers UNICODE
CompilerElse
;;;;; Univers NON UNICODE
MessageRequester("ATTENTION", " Vous devez Compiler en mode UNICODE")
End
CompilerEndIf
Static FLAG_KEYGEN=0
If FLAG_KEYGEN=0
;;;********* On peut retiter le blanc qui a une probabilité de 27% donc avec des risques de collision ****************
Static alphabet$="abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789,;:!<>?./§&é'(-è_çà)=~#{[|`\@]}+°%ù*µ^$£²"+Chr(34)
For i=160 To 255
alphabet$+Chr(I)
Next
FLAG_KEYGEN+1
EndIf
If deb_car<1
deb_car=1
EndIf
If fin_car>255
fin_car=255
EndIf
If deb_car>fin_car
deb_car=fin_car
EndIf
If fin_car=0
length=Len(alphabet$ )
Dim tab.c(length-1)
For i=0 To length-1
tab(i)=PeekC(@alphabet$+i*2) ;;;; Peekc définit l'adresse en octets alors que chaque élément de tab.c() est sur 2 octets
Next
; SortArray(tab(),#PB_Sort_Ascending ) ;;; pour mise au point et vérifier qu'il n'y a pas de doublon
fin_car=length-1
deb_car=0
Else
Dim tab.c(fin_car-deb_car)
For i=0 To fin_car-deb_car
tab(i)=I+deb_car
Next
EndIf
If DEB_RANDOM<>0
RandomSeed(DEB_RANDOM)
EndIf
RandomizeArray(tab())
cle$=""
For i=1 To LONG_CAR
nb=Random(fin_car,deb_car)
CLE$+Chr(tab(nb-deb_car))
Next
ProcedureReturn cle$
DisableExplicit
EndProcedure
Procedure.l KEYGEN_BSTR(LONG_CAR, DEB_RANDOM, deb_car,fin_car)
; ; sortie en BSTR pour générer une clè BSTR car XOR peut générer chr(0) (Collision)
; ; ces collisions peuvent rendre toutes les instructions PB sur string pratiquement inutilisables
;;;;; donc utilisation de la structure BSTR
ProcedureReturn STRINGtoBSTR(KEYGEN( LONG_CAR, DEB_RANDOM, deb_car,fin_car))
EndProcedure
Procedure.l XORALPHA(*CENT.string,*CPAW.string)
EnableExplicit
; ;Shared ou Global (voir aussi: Protected et Static).
Protected LONG=PeekL(*cent-4)
Protected Result,*ASORT.string=AllocateMemory(LONG+8);;,Cpass.s=space(200)
If PeekL(*cent-4)<>PeekL(*CPAW-4)
MessageRequester("ATTENTION"," Pour le moment les 2 chaines doivent avoir la même longueur")
End
EndIf
PokeS(*asort+4,Space(long/2))
Result = SysAllocString_(*ASORT+4)
CopyMemory(*CPAW-4,result-4,LONG+4);;; Pour convention BSTR l'adresse pointe sur la chaine et la longueur est à l'adresse -4
FreeMemory(*ASORT)
LONG=(LONG/4)+1
EnableASM
MOV esi, *CENT
MOV edi , Result
MOV ecx, LONG
!lab1:
MOV eax, [esi]
XOR [edi], eax
ADD esi,4
ADD edi,4
LOOP lab1
DisableASM
ProcedureReturn result
DisableExplicit
EndProcedure
Procedure.l EGALLONG(*CENT.string,*CPAW.string)
Protected lcent,lcpaw,difl
lcent=PeekL(*CENT-4)
lcpaw=PeekL(*CPAW-4)
difl=Sign(lcent-lcpaw )
Select difl
Case 0
ProcedureReturn *CPAW
Case 1
passwrd.s=""
For y= 0 To Lcent-2 Step 2
pos=y%lcpaw
passwrd.s+PeekS(*CPAW+pos,1)
Next
ProcedureReturn STRINGtoBSTR(passwrd)
Case -1
PokeL(*CPAW-4,PeekL(*CENT-4))
ProcedureReturn *CPAW
EndSelect
EndProcedure
;
chaine.s="toto de la Lune"+Chr(10)+"a la ligne"
K2.s="tito"
K3.s="pierre"
lchaine=Len(chaine)
; K2.s=rallonge_paw(K2,lchaine)
; K3.s=rallonge_paw(K3,lchaine)
*chaine=STRINGtoBSTR(chaine)
*K2=STRINGtoBSTR(K2)
*K3=STRINGtoBSTR(K3)
*K2=EGALLONG(*chaine,*K2) ;;; la longueur doit être la même que celle de la chaine
*K3=EGALLONG(*chaine,*K3) ;;; la longueur doit être la même que celle de la chaine
Debug "la chaine en clair= "+chaine.s
Debug "le password= K2="+K2.s; +_n(Len(K2))
Debug "le password= K3="+K3.s; +_n(Len(K3))
Debug ""
Debug ""
; on encode la chaine avec le mot de K2
*R2=XORALPHA(*chaine,*K2)
Debug "le resultat encodé= "+PeekS(*R2)
Debug ""
*K1=XORALPHA(*R2,*K3)
;;; A envoie K1 et K2 et K3 au 3 personnes
;;; ***** décodage OK malgré le mauvais ordre de decodage
*R2b=XORALPHA(*K2,*K3)
; Debug "le resultat décodé= "+PeekS(*R2b)
*R1b=XORALPHA(*R2b,*K1)
Debug "**** Bon résultat avec XORALPHA quelque soit l'ordre de décodage *K2 ! *K3 ! *K1*****"
Debug PeekS(*r1b)
;;; ***** décodage OK malgré le mauvais ordre de decodage
Debug ""
*R2b=XORALPHA(*K1,*K2)
; Debug "le resultat décodé= "+PeekS(*R2b)
*R1b=XORALPHA(*R2b,*K3)
Debug "**** Bon résultat avec XORALPHA quelque soit l'ordre de décodage *K1 ! *K2 ! *K3 *****"
Debug PeekS(*r1b)
;;; Bon ordre de décodage résultat OK
*R2b=XORALPHA(*K1,*K3)
; Debug "le resultat décodé= "+PeekS(*R2b)
*R1b=XORALPHA(*R2b,*K2)
Debug "**** Bon résultat ordre de décodage OK *K1 ! *K3 ! *K2 ******"
Debug PeekS(*r1b)
Debug ""
*R2b=XORALPHA(*K2,*K1)
; Debug "le resultat décodé= "+PeekS(*R2b)
*R1b=XORALPHA(*R2b,*K3)
Debug "**** Bon résultat avec XORALPHA quelque soit l'ordre de décodage *K2 ! *K1 ! *K3 ******"
Debug PeekS(*r1b)
Debug ""
*R2b=XORALPHA(*K3,*K1)
; Debug "le resultat décodé= "+PeekS(*R2b)
*R1b=XORALPHA(*R2b,*K2)
Debug "**** Bon résultat avec XORALPHA quelque soit l'ordre de décodage *K3 ! *K1 ! *K2 ******"
Debug PeekS(*r1b)
Debug ""
*R2b=XORALPHA(*K3,*K2)
; Debug "le resultat décodé= "+PeekS(*R2b)
*R1b=XORALPHA(*R2b,*K1)
Debug "**** Bon résultat avec XORALPHA quelque soit l'ordre de décodage *K3 ! *K2 ! *K1 ******"
Debug PeekS(*r1b)
Debug ""
debug ""
debug ""
debug "**** Toutes les permutations ont été réalisées et les résultats sont OK ********"
si tu n'as que la clef