CVE-2016-15006 (Other, published 2023-01-02T08:15Z)
Description: value: A vulnerability, which was classified as problematic, has been found in enigmaX up to 2.2. This issue affects the function getSeed of the file main.c of the component Scrambling Table Handler. The manipulation leads to predictable seed in pseudo-random number generator (prng). The attack may be initiated remotely. The complexity of an attack is rather high. The exploitation is known to be difficult. Upgrading to version 2.3 is able to address this issue. The identifier of the patch is 922bf90ca14a681629ba0b807a997a81d70225b5. It is recommended to upgrade the affected component. The identifier VDB-217181 was assigned to this vulnerability.
Severity: nan (CVSS v3 base score: 5.3)
Weakness: CWE-337 \u2014 Predictable Seed in Pseudo-Random Number Generator (PRNG)
A Pseudo-Random Number Generator (PRNG) is initialized from a predictable seed, such as the process ID or system time.
Repository: https://github.com/pfmonville/enigmaX
Files changed:
main.c
main.s
Commit message: 2.3

+ now the order of the scrambling tables when using a keyfile is
defined by the keyfile and not only with the password. Even if someone
has the password, without the keyfile it is impossible to do any
frequency analysis attack
~ fix the scrambling when a keyfile is used (previously the 16 tables
were the same)
~ some tweaks to descriptions


Vulnerable code:
			"%s(1)\t\t\tcopyright <Pierre-François Monville>\t\t\t%s(1)\n\nNAME\n\t%s -- crypt or decrypt any data\n\nSYNOPSIS\n\t%s [-h | --help] FILE [-s | --standard | KEYFILE]\n\nDESCRIPTION\n\t(FR) permet de chiffrer et de déchiffrer toutes les données entrées en paramètre le mot de passe demandé au début est hashé puis sert de graine pour le PRNG le PRNG permet de fournir une clé unique égale à la longueur du fichier à coder. La clé unique subit un xor avec le mot de passe (le mot de passe est répété autant de fois que nécéssaire). Le fichier subit un xor avec cette clé Puis un brouilleur est utilisé, il mélange la table des caractères (ascii) en utilisant le PRNG ou en utilisant le keyFile fourni.\n\t(EN) Can crypt and decrypt any data given in argument. The password asked is hashed to be used as a seed for the PRNG. The PRNG gives a unique key which has the same length as the source file. The key is xored with the password (the password is repeated as long as necessary). The file is then xored with this new key, then a scrambler is used. It scrambles the ascii table using the PRNG or the keyFile given\n\nOPTIONS\n\tthe options are as follows:\n\n\t-h | --help\tfurther help.\n\n\t-s | --standard\tput the scrambler on off.\n\n\t-i | --inverted\tinverts the coding/decoding process, first it xors then it scrambles.\n\nEXIT STATUS\n\tthe %s program exits 0 on success, and anything else if an error occurs.\n\nEXAMPLES\n\tthe command:\t%s file1\n\n\tlets you choose between crypting or decrypting then it will prompt for a password that crypt/decrypt file1 as xfile1 in the same folder, file1 is not modified.\n\n\tthe command:\t%s file2 keyfile1\n\n\tlets you choose between crypting or decrypting, will prompt for the password that crypt/decrypt file2, uses keyfile1 to generate the scrambler then crypt/decrypt file2 as file2x in the same folder, file2 is not modified.\n\n\tthe command:\t%s file3 -s\n\n\tlets you choose between crypting or decrypting, will prompt for a password that crypt/decrypt the file without using the scrambler, resulting in using the unique key only.\n", progName, progName, progName, progName, progName, progName, progName, progName);
			"Usage : %s [-h | --help] FILE [-s | --standard | -i | --inverted] [KEYFILE]\nOptions :\n  -h --help :\t\tfurther help\n  -s --standard :\tput the scrambler off\n  -i --inverted :\tinverts the coding/decoding process\n  KEYFILE :\t\tpath to a keyfile that generates the scrambler instead of the password\n", progName);
		if (keyFile != NULL){
					scrambleAsciiTables[j][i%256] = scrambleAsciiTables[j][(unsigned char)(extractedString[i])];
					scrambleAsciiTables[j][(unsigned char)(extractedString[i])] = temp;
			xoredString[i] = scrambleAsciiTables[keyString[i] & (1+2+4+8)][(unsigned char)(extractedString[i] ^ keyString[i])];
			xoredString[i] = scrambleAsciiTables[keyString[i] & (1+2+4+8)][(unsigned char)extractedString[i]] ^ keyString[i];
			xoredString[i] = unscrambleAsciiTables[keyString[i] & (1+2+4+8)][(unsigned char)extractedString[i]] ^ keyString[i];
			xoredString[i] = unscrambleAsciiTables[keyString[i] & (1+2+4+8)][(unsigned char)(extractedString[i] ^ keyString[i])];
	returned value : the size of the data reed
	subq	$16408, %rsp            ## imm = 0x4018
	movq	%rdi, %r12
	xorl	%r13d, %r13d
	testq	%r12, %r12
	je	LBB8_8
## BB#1:
	leaq	_scrambleAsciiTables(%rip), %rax
	leaq	-16432(%rbp), %r14
	leaq	_scrambleAsciiTables(%rip), %r15
LBB8_2:                                 ## %vector.ph
                                        ##     Child Loop BB8_3 Depth 2
                                        ##       Child Loop BB8_7 Depth 3
	movq	%rax, -16440(%rbp)      ## 8-byte Spill
LBB8_3:                                 ## %vector.body
                                        ##   Parent Loop BB8_2 Depth=1
	jne	LBB8_3
## BB#4:                                ## %middle.block
                                        ##   in Loop: Header=BB8_2 Depth=1
	movq	%r14, %rdi
	jmp	LBB8_5
	.align	4, 0x90
LBB8_6:                                 ## %.lr.ph.preheader
                                        ##   in Loop: Header=BB8_5 Depth=2
	movl	%eax, %r8d
	xorl	%ecx, %ecx
LBB8_7:                                 ## %.lr.ph
                                        ##   Parent Loop BB8_2 Depth=1
                                        ##     Parent Loop BB8_5 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movl	%ecx, %edx
	sarl	$31, %edx
	shrl	$24, %edx
	addl	%ecx, %edx
	andl	$-256, %edx
	movl	%ecx, %esi
	subl	%edx, %esi
	movslq	%esi, %rdx
	movq	%r13, %rsi
	shlq	$8, %rsi
	addq	%r15, %rsi
	movb	(%rdx,%rsi), %bl
	movzbl	-16432(%rbp,%rcx), %edi
	movb	(%rdi,%rsi), %al
	movb	%al, (%rdx,%rsi)
	movb	%bl, (%rdi,%rsi)
	incq	%rcx
	cmpl	%ecx, %r8d
	jne	LBB8_7
LBB8_5:                                 ## %.loopexit
                                        ##   Parent Loop BB8_2 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB8_7 Depth 3
	movq	%r14, %rdi
	movq	%r12, %rcx
	jg	LBB8_6
## BB#16:                               ## %._crit_edge
                                        ##   in Loop: Header=BB8_2 Depth=1
	movq	%r12, %rdi
	callq	_rewind
	incq	%r13
	movq	-16440(%rbp), %rax      ## 8-byte Reload
	addq	$256, %rax              ## imm = 0x100
	cmpq	$16, %r13
	pxor	%xmm1, %xmm1
	movdqa	LCPI8_0(%rip), %xmm2    ## xmm2 = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
	jne	LBB8_2
	jmp	LBB8_14
LBB8_8:                                 ## %.preheader5.us.preheader
	movq	_seed.1(%rip), %r15
	leaq	_scrambleAsciiTables(%rip), %r9
	movq	_passIndex(%rip), %r14
	xorl	%r11d, %r11d
	pxor	%xmm0, %xmm0
	movdqa	LCPI8_0(%rip), %xmm1    ## xmm1 = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
	movq	_passPhrase@GOTPCREL(%rip), %r10
	movq	%r9, %rax
LBB8_9:                                 ## %vector.ph45
                                        ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB8_10 Depth 2
                                        ##     Child Loop BB8_11 Depth 2
	movq	%rax, -16440(%rbp)      ## 8-byte Spill
	movq	%rax, %rbx
	xorl	%edi, %edi
LBB8_10:                                ## %vector.body41
                                        ##   Parent Loop BB8_9 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movd	%edi, %xmm2
	pshufb	%xmm0, %xmm2
	paddb	%xmm1, %xmm2
	movdqa	%xmm2, (%rbx)
	addq	$16, %rdi
	addq	$16, %rbx
	xorl	%eax, %eax
	cmpq	$256, %rdi              ## imm = 0x100
	jne	LBB8_10
LBB8_11:                                ## %.preheader3.us
                                        ##   Parent Loop BB8_9 Depth=1
	leal	(%r15,%rdx), %r12d
	xorq	%rdx, %r15
	movq	%rdx, %rdi
	rolq	$55, %rdi
	movq	%r15, %rdx
	xorq	%r15, %rdx
	xorq	%rdi, %rdx
	rolq	$36, %r15
	movzbl	(%r10,%r14), %r13d
	incl	%r14d
	andl	$16383, %r14d           ## imm = 0x3FFF
	movl	%eax, %esi
	addl	%eax, %esi
	movl	%eax, %ecx
	subl	%esi, %ecx
	movslq	%ecx, %rcx
	movq	%r11, %rsi
	shlq	$8, %rsi
	addq	%r9, %rsi
	movb	(%rcx,%rsi), %r8b
	movzbl	%r12b, %edi
	xorq	%r13, %rdi
	movb	(%rdi,%rsi), %bl
	movb	%bl, (%rcx,%rsi)
	movb	%r8b, (%rdi,%rsi)
	incl	%eax
	cmpl	$2560, %eax             ## imm = 0xA00
	jne	LBB8_11
## BB#12:                               ## %.loopexit4.us
                                        ##   in Loop: Header=BB8_9 Depth=1
	incq	%r11
	movq	-16440(%rbp), %rax      ## 8-byte Reload
	addq	$256, %rax              ## imm = 0x100
	cmpq	$16, %r11
	jne	LBB8_9
## BB#13:                               ## %.us-lcssa.us.loopexit
	movq	%r15, _seed.1(%rip)
	movq	%r14, _passIndex(%rip)
LBB8_14:                                ## %.us-lcssa.us
	jne	LBB8_17
## BB#15:                               ## %.us-lcssa.us
	addq	$16408, %rsp            ## imm = 0x4018
LBB8_17:                                ## %.us-lcssa.us
	movzbl	(%rsi), %r9d
	movb	(%rdi), %al
	xorb	%r9b, %al
	movzbl	%al, %eax
	andl	$15, %r9d
	shlq	$8, %r9
	addq	%r8, %r9
	movb	(%rax,%r9), %al
LBB10_1:                                ## %.preheader1
LBB10_3:                                ## %.lr.ph5
	movzbl	(%rdi), %r9d
	movzbl	(%rsi), %r10d
	movl	%r10d, %eax
	andl	$15, %eax
	shlq	$8, %rax
	addq	%r8, %rax
	movb	(%r9,%rax), %al
	xorb	%r10b, %al
	movzbl	(%rdi), %r9d
	movzbl	(%rsi), %r10d
	movl	%r10d, %eax
	andl	$15, %eax
	shlq	$8, %rax
	addq	%r8, %rax
	movb	(%r9,%rax), %al
	xorb	%r10b, %al
LBB11_1:                                ## %.preheader1
LBB11_3:                                ## %.lr.ph5
	movzbl	(%rsi), %r9d
	movb	(%rdi), %al
	xorb	%r9b, %al
	movzbl	%al, %eax
	andl	$15, %r9d
	shlq	$8, %r9
	addq	%r8, %r9
	movb	(%rax,%r9), %al
	movq	%rdi, %r14
	movq	_fileName(%rip), %rbx
	movq	%rbx, %rdi
	movq	%rsp, %r15
	subq	%rcx, %r15
	movq	%r15, %rsp
	leaq	L_.str(%rip), %rcx
	movq	%r15, %rdi
	movq	%rbx, %r9
	leaq	L_.str.1(%rip), %rsi
	movq	%r15, %rdi
	leaq	L_str(%rip), %rdi
	movq	%r14, %rdi
	movq	%r14, %r12
	leaq	-16432(%rbp), %r12
	leaq	-32816(%rbp), %r13
	movq	%r12, %rdi
## BB#15:                               ## %.lr.ph.i.30
	movq	%r13, %r9
## BB#17:                               ## %.lr.ph.i.41.preheader
	movq	%r13, %rbx
	movq	%r12, %rdx
LBB14_22:                               ## %.lr.ph.i.41.preheader87
LBB14_23:                               ## %.lr.ph.i.41
	movq	%r12, %r13
	cvttss2si	%xmm0, %r12d
	leaq	L_.str.28(%rip), %rdi
	testl	%r12d, %r12d
	movl	%r12d, %ebx
LBB14_50:                               ## %.lr.ph5.i.11
	cmpl	$49, %r12d
LBB14_46:                               ## %.lr.ph.i.14.preheader
	subl	%r12d, %ebx
LBB14_47:                               ## %.lr.ph.i.14
LBB14_48:                               ## %._crit_edge.i.12
	leaq	L_.str.31(%rip), %rdi
	movq	%r13, %r12
	leaq	-32816(%rbp), %r13
LBB14_2:                                ## %loadBar.exit26.preheader
	movq	_passPhrase@GOTPCREL(%rip), %r12
	leaq	_scrambleAsciiTables(%rip), %r13
LBB14_4:                                ## %.lr.ph51
	leaq	-32816(%rbp), %r9
	xorb	(%r12,%rsi), %dil
	movb	_isCodingInverted(%rip), %cl
	movq	%r14, %rdx
	leaq	-32816(%rbp), %rsi
	leaq	-49200(%rbp), %rdi
	movzbl	(%rsi), %ebx
	movb	(%rdx), %cl
	xorb	%bl, %cl
	movzbl	%cl, %ecx
	andl	$15, %ebx
	shlq	$8, %rbx
	addq	%r13, %rbx
	movb	(%rcx,%rbx), %cl
	movb	%cl, (%rdi)
	incq	%rdx
LBB14_9:                                ## %.preheader1.i
## BB#10:                               ## %.lr.ph5.i.preheader
	movl	%eax, %ecx
	movq	%r14, %rdx
	leaq	-32816(%rbp), %rsi
	leaq	-49200(%rbp), %rdi
LBB14_11:                               ## %.lr.ph5.i
	movzbl	(%rdx), %r8d
	movzbl	(%rsi), %r9d
	movl	%r9d, %ebx
	andl	$15, %ebx
	shlq	$8, %rbx
	addq	%r13, %rbx
	movb	(%r8,%rbx), %bl
	xorb	%r9b, %bl
	movb	%bl, (%rdi)
	incq	%rdi
	incq	%rdx
	decl	%ecx
	leaq	L_.str.28(%rip), %rdi
LBB14_44:                               ## %.lr.ph5.i.20
## BB#39:                               ## %.preheader.i.16
LBB14_40:                               ## %.lr.ph.i.25.preheader
LBB14_41:                               ## %.lr.ph.i.25
LBB14_42:                               ## %._crit_edge.i.21
	leaq	L_.str.31(%rip), %rdi
LBB14_34:                               ## %loadBar.exit26.backedge
	movq	%r15, %rdi
	leaq	L_str.47(%rip), %rdi
	movq	%rsp, %r12
	subq	%rcx, %r12
	movq	%r12, %rsp
	leaq	_unscrambleAsciiTables(%rip), %r15
	addq	%r15, %rcx
	leaq	L_.str.4(%rip), %rcx
	movq	%r12, %rdi
	movq	%r12, %rsi
	leaq	L_.str.1(%rip), %rsi
	leaq	L_str.35(%rip), %rdi
	leaq	-16432(%rbp), %r12
	leaq	-32816(%rbp), %r13
	movq	%r12, %rdi
## BB#19:                               ## %.lr.ph.i.33
	movq	%r13, %r9
## BB#21:                               ## %.lr.ph.i.44.preheader
	movq	%r13, %rbx
	movq	%r12, %rdx
LBB15_26:                               ## %.lr.ph.i.44.preheader90
LBB15_27:                               ## %.lr.ph.i.44
	movq	%r12, %r13
	cvttss2si	%xmm0, %r12d
	leaq	L_.str.28(%rip), %rdi
	testl	%r12d, %r12d
	movl	%r12d, %ebx
	cmpl	$49, %r12d
	subl	%r12d, %ebx
	leaq	L_.str.31(%rip), %rdi
	movq	%r13, %r12
	leaq	-32816(%rbp), %r13
LBB15_6:                                ## %loadBar.exit29.preheader
	xorl	%r12d, %r12d
LBB15_8:                                ## %.lr.ph54
	leaq	-32816(%rbp), %r9
	movb	_isCodingInverted(%rip), %cl
	movl	%eax, %ecx
	movq	%r14, %rdx
	leaq	-32816(%rbp), %rsi
	leaq	-49200(%rbp), %rdi
	movzbl	(%rdx), %r8d
	movzbl	(%rsi), %r9d
	movl	%r9d, %ebx
	andl	$15, %ebx
	shlq	$8, %rbx
	addq	%r15, %rbx
	movb	(%r8,%rbx), %bl
	xorb	%r9b, %bl
	movb	%bl, (%rdi)
	incq	%rdx
	decl	%ecx
LBB15_13:                               ## %.preheader1.i
## BB#14:                               ## %.lr.ph5.i.17.preheader
	movq	%r14, %rdx
	leaq	-32816(%rbp), %rsi
	leaq	-49200(%rbp), %rdi
LBB15_15:                               ## %.lr.ph5.i.17
	movzbl	(%rsi), %ebx
	movb	(%rdx), %cl
	xorb	%bl, %cl
	movzbl	%cl, %ecx
	andl	$15, %ebx
	shlq	$8, %rbx
	addq	%r15, %rbx
	movb	(%rcx,%rbx), %cl
	movb	%cl, (%rdi)
	incq	%rdx
	incq	%r12
	movl	%r12d, %eax
	cvtsi2ssl	%r12d, %xmm1
	leaq	L_.str.28(%rip), %rdi
LBB15_46:                               ## %.lr.ph5.i.23
## BB#41:                               ## %.preheader.i.19
LBB15_42:                               ## %.lr.ph.i.28.preheader
LBB15_43:                               ## %.lr.ph.i.28
LBB15_44:                               ## %._crit_edge.i.24
	leaq	L_.str.31(%rip), %rdi
LBB15_38:                               ## %loadBar.exit29.backedge
	movq	%r12, %rdi
	leaq	L_str.47(%rip), %rdi
	leaq	L_str.38(%rip), %rdi
	leaq	L_.str.7(%rip), %rdi
	leaq	L_str.47(%rip), %rdi
	jge	LBB17_21
	leaq	L_.str.9(%rip), %rsi
	je	LBB17_88
	leaq	L_.str.10(%rip), %rsi
	je	LBB17_88
	leaq	L_.str.11(%rip), %rsi
	leaq	L_.str.12(%rip), %rsi
## BB#14:
	leaq	L_.str.15(%rip), %rsi
	je	LBB17_16
## BB#15:
	leaq	L_.str.16(%rip), %rsi
	je	LBB17_16
## BB#18:
	leaq	L_.str.13(%rip), %rsi
	je	LBB17_19
## BB#20:
	jl	LBB17_23
LBB17_21:
	leaq	L_str.50(%rip), %rdi
	leaq	L_.str.13(%rip), %rsi
## BB#22:
	leaq	L_str.49(%rip), %rdi
LBB17_16:
## BB#17:
	leaq	L_.str.13(%rip), %rsi
LBB17_23:
	leaq	L_.str.18(%rip), %rdi
	leaq	L_.str.19(%rip), %rcx
	leaq	L_.str.20(%rip), %rcx
	leaq	L_str.42(%rip), %rdi
	leaq	L_.str.23(%rip), %rcx
	leaq	L_.str.13(%rip), %rsi
## BB#39:                               ## %.thread
	leaq	L_.str.13(%rip), %rsi
	leaq	L_.str.24(%rip), %r14
	leaq	L_.str.25(%rip), %r13
LBB17_61:                               ## %.thread20.loopexit
LBB17_62:                               ## %.thread20
	leaq	L_.str.26(%rip), %rdi
	leaq	L_.str.25(%rip), %rdi
	leaq	L_str.40(%rip), %rdi
	jne	LBB17_89
	leaq	L_str.47(%rip), %rdi
	leaq	L_str.47(%rip), %rdi
LBB17_88:
LBB17_89:
	leaq	L_str.44(%rip), %rdi
	leaq	L_str.46(%rip), %rdi
	leaq	L_str.47(%rip), %rdi
LBB17_19:
	leaq	L_.str.32(%rip), %rsi
	leaq	L_.str.33(%rip), %rsi
L_.str:                                 ## @.str
L_.str.1:                               ## @.str.1
L_.str.4:                               ## @.str.4
L_.str.7:                               ## @.str.7
L_.str.9:                               ## @.str.9
L_.str.10:                              ## @.str.10
L_.str.11:                              ## @.str.11
L_.str.12:                              ## @.str.12
L_.str.13:                              ## @.str.13
L_.str.15:                              ## @.str.15
L_.str.16:                              ## @.str.16
L_.str.18:                              ## @.str.18
L_.str.19:                              ## @.str.19
L_.str.20:                              ## @.str.20
L_.str.23:                              ## @.str.23
L_.str.24:                              ## @.str.24
L_.str.25:                              ## @.str.25
L_.str.26:                              ## @.str.26
L_.str.28:                              ## @.str.28
L_.str.31:                              ## @.str.31
	.asciz	"] %.0f        \r"

	.asciz	"%s(1)\t\t\tcopyright <Pierre-Fran\303\247ois Monville>\t\t\t%s(1)\n\nNAME\n\t%s -- crypt or decrypt any data\n\nSYNOPSIS\n\t%s [-h | --help] FILE [-s | --standard | KEYFILE]\n\nDESCRIPTION\n\t(FR) permet de chiffrer et de d\303\251chiffrer toutes les donn\303\251es entr\303\251es en param\303\250tre le mot de passe demand\303\251 au d\303\251but est hash\303\251 puis sert de graine pour le PRNG le PRNG permet de fournir une cl\303\251 unique \303\251gale \303\240 la longueur du fichier \303\240 coder. La cl\303\251 unique subit un xor avec le mot de passe (le mot de passe est r\303\251p\303\251t\303\251 autant de fois que n\303\251c\303\251ssaire). Le fichier subit un xor avec cette cl\303\251 Puis un brouilleur est utilis\303\251, il m\303\251lange la table des caract\303\250res (ascii) en utilisant le PRNG ou en utilisant le keyFile fourni.\n\t(EN) Can crypt and decrypt any data given in argument. The password asked is hashed to be used as a seed for the PRNG. The PRNG gives a unique key which has the same length as the source file. The key is xored with the password (the password is repeated as long as necessary). The file is then xored with this new key, then a scrambler is used. It scrambles the ascii table using the PRNG or the keyFile given\n\nOPTIONS\n\tthe options are as follows:\n\n\t-h | --help\tfurther help.\n\n\t-s | --standard\tput the scrambler on off.\n\n\t-i | --inverted\tinverts the coding/decoding process, first it xors then it scrambles.\n\nEXIT STATUS\n\tthe %s program exits 0 on success, and anything else if an error occurs.\n\nEXAMPLES\n\tthe command:\t%s file1\n\n\tlets you choose between crypting or decrypting then it will prompt for a password that crypt/decrypt file1 as xfile1 in the same folder, file1 is not modified.\n\n\tthe command:\t%s file2 keyfile1\n\n\tlets you choose between crypting or decrypting, will prompt for the password that crypt/decrypt file2, uses keyfile1 to generate the scrambler then crypt/decrypt file2 as file2x in the same folder, file2 is not modified.\n\n\tthe command:\t%s file3 -s\n\n\tlets you choose between crypting or decrypting, will prompt for a password that crypt/decrypt the file without using the scrambler, resulting in using the unique key only.\n"
	.asciz	"Usage : %s [-h | --help] FILE [-s | --standard | -i | --inverted] [KEYFILE]\nOptions :\n  -h --help :\t\tfurther help\n  -s --standard :\tput the scrambler off\n  -i --inverted :\tinverts the coding/decoding process\n  KEYFILE :\t\tpath to a keyfile that generates the scrambler instead of the password\n"
	.asciz	"starting encryption..."
	.asciz	"starting decryption..."
	.align	4                       ## @str.38
L_str.38:
	.asciz	"error: file's path is not correct, one or several directories and or file are missing"
	.asciz	"Done                                                                  "
	.asciz	"\rregrouping the folder in one file using tar... Done          "
	.asciz	"\nerror: unable to tar your file"
L_str.47:                               ## @str.47
	.align	4                       ## @str.49
L_str.49:
	.align	4                       ## @str.50
L_str.50:

Fixed code:
static char usingKeyFile = 0;
static char scramblingTablesOrder[BUFFER_SIZE];
			"%s(1)\t\t\tcopyright <Pierre-François Monville>\t\t\t%s(1)\n\nNAME\n\t%s -- crypt or decrypt any data\n\nSYNOPSIS\n\t%s [-h | --help] FILE [-s | --standard | KEYFILE]\n\nDESCRIPTION\n\t(FR) permet de chiffrer et de déchiffrer toutes les données entrées en paramètre le mot de passe demandé au début est hashé puis sert de graine pour le PRNG le PRNG permet de fournir une clé unique égale à la longueur du fichier à coder. La clé unique subit un xor avec le mot de passe (le mot de passe est répété autant de fois que nécéssaire). Le fichier subit un xor avec cette clé Puis un brouilleur est utilisé, il mélange la table des caractères (ascii) en utilisant le PRNG ou en utilisant le keyFile fourni.\n\t(EN) Can crypt and decrypt any data given in argument. The password asked is hashed to be used as a seed for the PRNG. The PRNG gives a unique key which has the same length as the source file. The key is xored with the password (the password is repeated as long as necessary). The file is then xored with this new key, then a scrambler is used. It scrambles the ascii table using the PRNG or the keyFile given\n\nOPTIONS\n\tthe options are as follows:\n\n\t-h | --help\tfurther help.\n\n\t-s | --standard\tput the scrambler on off.\n\n\t-i | --inverted\tinverts the coding/decoding process, first it xors then it scrambles.\n\n\tKEYFILE    \tthe path to a file which will be used to scramble the substitution's tables and choose in which order they will be used instead of the PRNG only (starting at 2.5 ko for the keyfile is great, however not interesting to be too heavy) \n\nEXIT STATUS\n\tthe %s program exits 0 on success, and anything else if an error occurs.\n\nEXAMPLES\n\tthe command:\t%s file1\n\n\tlets you choose between crypting or decrypting then it will prompt for a password that crypt/decrypt file1 as xfile1 in the same folder, file1 is not modified.\n\n\tthe command:\t%s file2 keyfile1\n\n\tlets you choose between crypting or decrypting, will prompt for the password that crypt/decrypt file2, uses keyfile1 to generate the scrambler then crypt/decrypt file2 as file2x in the same folder, file2 is not modified.\n\n\tthe command:\t%s file3 -s\n\n\tlets you choose between crypting or decrypting, will prompt for a password that crypt/decrypt the file without using the scrambler, resulting in using the unique key only.\n", progName, progName, progName, progName, progName, progName, progName, progName);
			"Version : 2.3\nUsage : %s [-h | --help] FILE [-s | --standard | -i | --inverted] [KEYFILE]\nOptions :\n  -h --help :\t\tfurther help\n  -s --standard :\tput the scrambler off\n  -i --inverted :\tinverts the coding/decoding process\n  KEYFILE :\t\tpath to a keyfile that scrambles the substitution's tables and choose they order instead of the PRNG only\n", progName);
	printf("scrambling substitution's tables...\n");
		if (usingKeyFile){
			unsigned char random256;
					random256 = generateNumber() ^ extractedString[i];
					scrambleAsciiTables[j][i%256] = scrambleAsciiTables[j][random256];
					scrambleAsciiTables[j][random256] = temp;
	if(usingKeyFile){
		int j = 0;
		char temp[BUFFER_SIZE];
		while(j < BUFFER_SIZE){
			int charactersRead = fread(temp, 1, BUFFER_SIZE, keyFile);
			if(charactersRead == 0){
				rewind(keyFile);
				continue;
			}
			for (int i = 0; i < charactersRead; ++i)
			{
				scramblingTablesOrder[j] = temp[i] & (1+2+4+8);
				j++;
				if(j == BUFFER_SIZE){
					break;
				}
			}
		}
	}
	char* tablenumber;

	if(usingKeyFile){
		tablenumber = scramblingTablesOrder;
	}else{
		tablenumber = keyString;
	}
			xoredString[i] = scrambleAsciiTables[tablenumber[i] & (1+2+4+8)][(unsigned char)(extractedString[i] ^ keyString[i])];
			xoredString[i] = scrambleAsciiTables[tablenumber[i] & (1+2+4+8)][(unsigned char)extractedString[i]] ^ keyString[i];
	char* tablenumber;

	if(usingKeyFile){
		tablenumber = scramblingTablesOrder;
	}else{
		tablenumber = keyString;
	}
			xoredString[i] = unscrambleAsciiTables[tablenumber[i] & (1+2+4+8)][(unsigned char)extractedString[i]] ^ keyString[i];
			xoredString[i] = unscrambleAsciiTables[tablenumber[i] & (1+2+4+8)][(unsigned char)(extractedString[i] ^ keyString[i])];
	returned value : the size of the data read

		if(keyFile != NULL){
			usingKeyFile = 1;
		}
	subq	$16424, %rsp            ## imm = 0x4028
	movq	%rdi, -16440(%rbp)      ## 8-byte Spill
	leaq	L_str(%rip), %rdi
	callq	_puts
	leaq	_scrambleAsciiTables(%rip), %r13
	xorl	%r14d, %r14d
	movq	_passPhrase@GOTPCREL(%rip), %rsi
	movq	%r13, %r12
LBB8_1:                                 ## %vector.ph
                                        ##     Child Loop BB8_2 Depth 2
                                        ##     Child Loop BB8_9 Depth 2
                                        ##       Child Loop BB8_11 Depth 3
	movq	%r12, %rax
LBB8_2:                                 ## %vector.body
                                        ##   Parent Loop BB8_1 Depth=1
	jne	LBB8_2
## BB#3:                                ## %middle.block
                                        ##   in Loop: Header=BB8_1 Depth=1
	movb	_usingKeyFile(%rip), %al
	andb	$1, %al
	je	LBB8_4
## BB#7:                                ##   in Loop: Header=BB8_1 Depth=1
	leaq	-16432(%rbp), %rbx
	movq	%rbx, %rdi
	movl	$1, %esi
	movl	$16384, %edx            ## imm = 0x4000
	movq	%rbx, %rdi
	jmp	LBB8_9
LBB8_8:                                 ## %.loopexit11
                                        ##   in Loop: Header=BB8_9 Depth=2
	movq	%rdx, _seed.0(%rip)
	movq	%rcx, _seed.1(%rip)
	leaq	-16432(%rbp), %rdi
LBB8_9:                                 ## %.loopexit11
                                        ##   Parent Loop BB8_1 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB8_11 Depth 3
	movq	-16440(%rbp), %rcx      ## 8-byte Reload
	jle	LBB8_12
## BB#10:                               ## %.lr.ph24
                                        ##   in Loop: Header=BB8_9 Depth=2
	movq	_seed.1(%rip), %rcx
	movl	%eax, %r8d
	xorl	%esi, %esi
LBB8_11:                                ##   Parent Loop BB8_1 Depth=1
                                        ##     Parent Loop BB8_9 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leal	(%rcx,%rdx), %r9d
	xorq	%rdx, %rcx
	movq	%rdx, %rbx
	rolq	$55, %rbx
	movq	%rcx, %rdx
	shlq	$14, %rdx
	xorq	%rcx, %rdx
	xorq	%rbx, %rdx
	rolq	$36, %rcx
	movzbl	-16432(%rbp,%rsi), %r10d
	movl	%esi, %eax
	sarl	$31, %eax
	shrl	$24, %eax
	addl	%esi, %eax
	andl	$-256, %eax
	movl	%esi, %edi
	subl	%eax, %edi
	movslq	%edi, %r15
	movq	%r14, %rdi
	shlq	$8, %rdi
	addq	%r13, %rdi
	movb	(%r15,%rdi), %r11b
	movzbl	%r9b, %ebx
	xorq	%r10, %rbx
	movb	(%rbx,%rdi), %al
	movb	%al, (%r15,%rdi)
	movb	%r11b, (%rbx,%rdi)
	incq	%rsi
	cmpl	%esi, %r8d
	jne	LBB8_11
	jmp	LBB8_8
LBB8_4:                                 ## %.preheader12
                                        ##   in Loop: Header=BB8_1 Depth=1
	movq	%r12, -16448(%rbp)      ## 8-byte Spill
	movq	_seed.0(%rip), %rdx
	movq	_seed.1(%rip), %rax
	xorl	%r9d, %r9d
	movq	_passIndex(%rip), %r15
LBB8_5:                                 ##   Parent Loop BB8_1 Depth=1
	leal	(%rax,%rdx), %r8d
	xorq	%rdx, %rax
	movq	%rdx, %rbx
	rolq	$55, %rbx
	movq	%rax, %rdx
	xorq	%rax, %rdx
	xorq	%rbx, %rdx
	rolq	$36, %rax
	movzbl	(%rsi,%r15), %r10d
	incl	%r15d
	andl	$16383, %r15d           ## imm = 0x3FFF
	movq	%rsi, %r12
	movl	%r9d, %esi
	addl	%r9d, %esi
	movl	%r9d, %edi
	subl	%esi, %edi
	movslq	%edi, %rsi
	movq	%r14, %rdi
	shlq	$8, %rdi
	addq	%r13, %rdi
	movb	(%rsi,%rdi), %r11b
	movzbl	%r8b, %ebx
	xorq	%r10, %rbx
	movb	(%rbx,%rdi), %cl
	movb	%cl, (%rsi,%rdi)
	movq	%r12, %rsi
	movb	%r11b, (%rbx,%rdi)
	incl	%r9d
	cmpl	$2560, %r9d             ## imm = 0xA00
	jne	LBB8_5
## BB#6:                                ## %.loopexit13
                                        ##   in Loop: Header=BB8_1 Depth=1
	movq	%rax, _seed.1(%rip)
	movq	%r15, _passIndex(%rip)
	movq	-16448(%rbp), %r12      ## 8-byte Reload
	jmp	LBB8_13
	.align	4, 0x90
LBB8_12:                                ## %._crit_edge.25
                                        ##   in Loop: Header=BB8_1 Depth=1
	movq	-16440(%rbp), %rdi      ## 8-byte Reload
	callq	_rewind
	pxor	%xmm1, %xmm1
	movdqa	LCPI8_0(%rip), %xmm2    ## xmm2 = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
	movq	_passPhrase@GOTPCREL(%rip), %rsi
LBB8_13:                                ##   in Loop: Header=BB8_1 Depth=1
	incq	%r14
	addq	$256, %r12              ## imm = 0x100
	cmpq	$16, %r14
	jne	LBB8_1
## BB#14:
	movb	_usingKeyFile(%rip), %al
	andb	$1, %al
	je	LBB8_23
## BB#15:
	xorl	%ebx, %ebx
	leaq	-16432(%rbp), %r14
	leaq	_scramblingTablesOrder(%rip), %r15
	movq	-16440(%rbp), %r12      ## 8-byte Reload
	jmp	LBB8_18
	.align	4, 0x90
LBB8_17:                                ## %.lr.ph.split.us
                                        ##   in Loop: Header=BB8_18 Depth=1
	movq	%r12, %rdi
	callq	_rewind
LBB8_18:                                ## %.lr.ph.split.us
                                        ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB8_22 Depth 2
	movl	$1, %esi
	movl	$16384, %edx            ## imm = 0x4000
	movq	%r14, %rdi
	movq	%r12, %rcx
	callq	_fread
	testl	%eax, %eax
	je	LBB8_17
## BB#19:                               ## %.preheader
                                        ##   in Loop: Header=BB8_18 Depth=1
	testl	%eax, %eax
	jle	LBB8_16
## BB#20:                               ## %.lr.ph17.preheader
                                        ##   in Loop: Header=BB8_18 Depth=1
	cltq
	movslq	%ebx, %rbx
	xorl	%ecx, %ecx
	.align	4, 0x90
LBB8_22:                                ## %.lr.ph17
                                        ##   Parent Loop BB8_18 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movb	-16432(%rbp,%rcx), %dl
	andb	$15, %dl
	movb	%dl, (%rbx,%r15)
	cmpl	$16383, %ebx            ## imm = 0x3FFF
	je	LBB8_23
## BB#21:                               ##   in Loop: Header=BB8_22 Depth=2
	incq	%rcx
	incq	%rbx
	cmpq	%rax, %rcx
	jl	LBB8_22
LBB8_16:                                ## %.loopexit
                                        ##   in Loop: Header=BB8_18 Depth=1
	cmpl	$16383, %ebx            ## imm = 0x3FFF
	jle	LBB8_18
LBB8_23:
	jne	LBB8_25
## BB#24:
	addq	$16424, %rsp            ## imm = 0x4028
LBB8_25:
	movb	_usingKeyFile(%rip), %al
	andb	$1, %al
	leaq	_scramblingTablesOrder(%rip), %r9
	cmoveq	%rsi, %r9
	movb	(%rsi), %al
	xorb	(%rdi), %al
	movzbl	%al, %r10d
	movzbl	(%r9), %eax
	andl	$15, %eax
	shlq	$8, %rax
	addq	%r8, %rax
	movb	(%r10,%rax), %al
	incq	%r9
LBB10_1:                                ## %.preheader2
LBB10_3:                                ## %.lr.ph6
	movzbl	(%rdi), %r10d
	movzbl	(%r9), %r11d
	andl	$15, %r11d
	shlq	$8, %r11
	addq	%r8, %r11
	movb	(%rsi), %al
	xorb	(%r10,%r11), %al
	incq	%r9
	movb	_usingKeyFile(%rip), %al
	andb	$1, %al
	leaq	_scramblingTablesOrder(%rip), %r9
	cmoveq	%rsi, %r9
	movzbl	(%rdi), %r10d
	movzbl	(%r9), %r11d
	andl	$15, %r11d
	shlq	$8, %r11
	addq	%r8, %r11
	movb	(%rsi), %al
	xorb	(%r10,%r11), %al
	incq	%r9
LBB11_1:                                ## %.preheader2
LBB11_3:                                ## %.lr.ph6
	movb	(%rsi), %al
	xorb	(%rdi), %al
	movzbl	%al, %r10d
	movzbl	(%r9), %eax
	andl	$15, %eax
	shlq	$8, %rax
	addq	%r8, %rax
	movb	(%r10,%rax), %al
	incq	%r9
	movq	%rdi, %r15
	movq	_fileName(%rip), %r14
	movq	%r14, %rdi
	movq	%rsp, %rbx
	subq	%rcx, %rbx
	movq	%rbx, %rsp
	leaq	L_.str.1(%rip), %rcx
	movq	%rbx, %rdi
	movq	%r14, %r9
	leaq	L_.str.2(%rip), %rsi
	movq	%rbx, %rdi
	leaq	L_str.35(%rip), %rdi
	movq	%r15, %rdi
	movq	%r15, %r12
	leaq	-16432(%rbp), %r13
	leaq	-32816(%rbp), %r12
	movq	%r13, %rdi
## BB#15:                               ## %.lr.ph.i.29
	movq	%r12, %r9
## BB#17:                               ## %.lr.ph.i.40.preheader
	movq	%r12, %rbx
	movq	%r13, %rdx
LBB14_22:                               ## %.lr.ph.i.40.preheader86
LBB14_23:                               ## %.lr.ph.i.40
	movq	%r13, %r12
	cvttss2si	%xmm0, %r13d
	leaq	L_.str.29(%rip), %rdi
	testl	%r13d, %r13d
	movl	%r13d, %ebx
LBB14_50:                               ## %.lr.ph5.i
	cmpl	$49, %r13d
LBB14_46:                               ## %.lr.ph.i.13.preheader
	subl	%r13d, %ebx
LBB14_47:                               ## %.lr.ph.i.13
LBB14_48:                               ## %._crit_edge.i.11
	leaq	L_.str.32(%rip), %rdi
	movq	%r12, %r13
	leaq	-32816(%rbp), %r12
LBB14_2:                                ## %loadBar.exit25.preheader
	movq	_passPhrase@GOTPCREL(%rip), %r13
	leaq	_scrambleAsciiTables(%rip), %r12
LBB14_4:                                ## %.lr.ph50
	leaq	-32816(%rbp), %r11
	movq	%r11, %r9
	xorb	(%r13,%rsi), %dil
	movb	_usingKeyFile(%rip), %cl
	movq	%r11, %rcx
	leaq	_scramblingTablesOrder(%rip), %rdx
	cmovneq	%rdx, %rcx
	movb	_isCodingInverted(%rip), %dl
	andb	$1, %dl
	movq	%r14, %rsi
	movq	%r11, %rdi
	leaq	-49200(%rbp), %rbx
	movb	(%rdi), %dl
	xorb	(%rsi), %dl
	movzbl	%dl, %r9d
	movzbl	(%rcx), %edx
	andl	$15, %edx
	shlq	$8, %rdx
	addq	%r12, %rdx
	movb	(%r9,%rdx), %dl
	movb	%dl, (%rbx)
	incq	%rbx
	incq	%rcx
LBB14_9:                                ## %.preheader2.i
## BB#10:                               ## %.lr.ph6.i.preheader
	movl	%eax, %r9d
	movq	%r14, %r10
	movq	%r11, %rdi
	leaq	-49200(%rbp), %rsi
LBB14_11:                               ## %.lr.ph6.i
	movzbl	(%r10), %r8d
	movzbl	(%rcx), %edx
	andl	$15, %edx
	shlq	$8, %rdx
	addq	%r12, %rdx
	movb	(%rdi), %bl
	xorb	(%r8,%rdx), %bl
	movb	%bl, (%rsi)
	incq	%rdi
	incq	%r10
	incq	%rcx
	decl	%r9d
	leaq	L_.str.29(%rip), %rdi
LBB14_44:                               ## %.lr.ph5.i.19
## BB#39:                               ## %.preheader.i.15
LBB14_40:                               ## %.lr.ph.i.24.preheader
LBB14_41:                               ## %.lr.ph.i.24
LBB14_42:                               ## %._crit_edge.i.20
	leaq	L_.str.32(%rip), %rdi
LBB14_34:                               ## %loadBar.exit25.backedge
	movq	%rbx, %rdi
	leaq	L_str.49(%rip), %rdi
	movq	%rsp, %r15
	subq	%rcx, %r15
	movq	%r15, %rsp
	leaq	_unscrambleAsciiTables(%rip), %r12
	addq	%r12, %rcx
	leaq	L_.str.5(%rip), %rcx
	movq	%r15, %rdi
	movq	%r15, %rsi
	leaq	L_.str.2(%rip), %rsi
	leaq	L_str.37(%rip), %rdi
	leaq	-16432(%rbp), %r13
	leaq	-32816(%rbp), %r12
	movq	%r13, %rdi
## BB#19:                               ## %.lr.ph.i.32
	movq	%r12, %r9
## BB#21:                               ## %.lr.ph.i.43.preheader
	movq	%r12, %rbx
	movq	%r13, %rdx
LBB15_26:                               ## %.lr.ph.i.43.preheader89
LBB15_27:                               ## %.lr.ph.i.43
	movq	%r13, %r12
	cvttss2si	%xmm0, %r13d
	leaq	L_.str.29(%rip), %rdi
	testl	%r13d, %r13d
	movl	%r13d, %ebx
	cmpl	$49, %r13d
	subl	%r13d, %ebx
	leaq	L_.str.32(%rip), %rdi
	movq	%r12, %r13
	leaq	-32816(%rbp), %r12
LBB15_6:                                ## %loadBar.exit28.preheader
	xorl	%r15d, %r15d
LBB15_8:                                ## %.lr.ph53
	leaq	-32816(%rbp), %r11
	movq	%r11, %r9
	movb	_usingKeyFile(%rip), %cl
	movq	%r11, %rsi
	leaq	_scramblingTablesOrder(%rip), %rcx
	cmovneq	%rcx, %rsi
	movb	_isCodingInverted(%rip), %dl
	andb	$1, %dl
	movl	%eax, %r9d
	movq	%r14, %r10
	movq	%r11, %rdi
	leaq	-49200(%rbp), %rbx
	movzbl	(%r10), %r8d
	movzbl	(%rsi), %edx
	andl	$15, %edx
	shlq	$8, %rdx
	addq	%r12, %rdx
	movb	(%rdi), %cl
	xorb	(%r8,%rdx), %cl
	movb	%cl, (%rbx)
	incq	%rbx
	incq	%r10
	decl	%r9d
LBB15_13:                               ## %.preheader2.i
## BB#14:                               ## %.lr.ph6.i.preheader
	movq	%r14, %rcx
	movq	%r11, %rdi
	leaq	-49200(%rbp), %rbx
LBB15_15:                               ## %.lr.ph6.i
	movb	(%rdi), %dl
	xorb	(%rcx), %dl
	movzbl	%dl, %r9d
	movzbl	(%rsi), %edx
	andl	$15, %edx
	shlq	$8, %rdx
	addq	%r12, %rdx
	movb	(%r9,%rdx), %dl
	movb	%dl, (%rbx)
	incq	%rbx
	incq	%rcx
	incq	%r15
	movl	%r15d, %eax
	cvtsi2ssl	%r15d, %xmm1
	leaq	L_.str.29(%rip), %rdi
LBB15_46:                               ## %.lr.ph5.i.22
## BB#41:                               ## %.preheader.i.18
LBB15_42:                               ## %.lr.ph.i.27.preheader
LBB15_43:                               ## %.lr.ph.i.27
LBB15_44:                               ## %._crit_edge.i.23
	leaq	L_.str.32(%rip), %rdi
LBB15_38:                               ## %loadBar.exit28.backedge
	movq	%r15, %rdi
	leaq	L_str.49(%rip), %rdi
	leaq	L_str.40(%rip), %rdi
	leaq	L_.str.8(%rip), %rdi
	leaq	L_str.49(%rip), %rdi
	jge	LBB17_88
	leaq	L_.str.10(%rip), %rsi
	je	LBB17_89
	leaq	L_.str.11(%rip), %rsi
	je	LBB17_89
	leaq	L_.str.12(%rip), %rsi
	leaq	L_.str.13(%rip), %rsi
## BB#15:
	leaq	L_.str.16(%rip), %rsi
	je	LBB17_17
## BB#16:
	leaq	L_.str.17(%rip), %rsi
	je	LBB17_17
## BB#19:
	leaq	L_.str.14(%rip), %rsi
	je	LBB17_20
## BB#21:
	jl	LBB17_22
LBB17_88:
	leaq	L_str.52(%rip), %rdi
	leaq	L_.str.14(%rip), %rsi
## BB#14:
	leaq	L_str.51(%rip), %rdi
LBB17_17:
## BB#18:
	leaq	L_.str.14(%rip), %rsi
LBB17_22:
	movb	$1, _usingKeyFile(%rip)
LBB17_23:                               ## %.thread
	leaq	L_.str.19(%rip), %rdi
	leaq	L_.str.20(%rip), %rcx
	leaq	L_.str.21(%rip), %rcx
	leaq	L_str.44(%rip), %rdi
	leaq	L_.str.24(%rip), %rcx
	leaq	L_.str.14(%rip), %rsi
## BB#39:                               ## %.thread20
	leaq	L_.str.14(%rip), %rsi
	leaq	L_.str.25(%rip), %r14
	leaq	L_.str.26(%rip), %r13
LBB17_61:                               ## %.thread22.loopexit
LBB17_62:                               ## %.thread22
	leaq	L_.str.27(%rip), %rdi
	leaq	L_.str.26(%rip), %rdi
	leaq	L_str.42(%rip), %rdi
	jne	LBB17_90
	leaq	L_str.49(%rip), %rdi
	leaq	L_str.49(%rip), %rdi
LBB17_89:
LBB17_90:
	leaq	L_str.46(%rip), %rdi
	leaq	L_str.48(%rip), %rdi
	leaq	L_str.49(%rip), %rdi
LBB17_20:
	leaq	L_.str.33(%rip), %rsi
	leaq	L_.str.34(%rip), %rsi
.zerofill __DATA,__bss,_usingKeyFile,1,0 ## @usingKeyFile
.zerofill __DATA,__bss,_scramblingTablesOrder,16384,4 ## @scramblingTablesOrder
L_.str.1:                               ## @.str.1
L_.str.2:                               ## @.str.2
L_.str.5:                               ## @.str.5
L_.str.8:                               ## @.str.8
L_.str.10:                              ## @.str.10
L_.str.11:                              ## @.str.11
L_.str.12:                              ## @.str.12
L_.str.13:                              ## @.str.13
L_.str.14:                              ## @.str.14
L_.str.16:                              ## @.str.16
L_.str.17:                              ## @.str.17
L_.str.19:                              ## @.str.19
L_.str.20:                              ## @.str.20
L_.str.21:                              ## @.str.21
L_.str.24:                              ## @.str.24
L_.str.25:                              ## @.str.25
L_.str.26:                              ## @.str.26
L_.str.27:                              ## @.str.27
L_.str.29:                              ## @.str.29
	.asciz	"] %.0f        \r"
	.asciz	"%s(1)\t\t\tcopyright <Pierre-Fran\303\247ois Monville>\t\t\t%s(1)\n\nNAME\n\t%s -- crypt or decrypt any data\n\nSYNOPSIS\n\t%s [-h | --help] FILE [-s | --standard | KEYFILE]\n\nDESCRIPTION\n\t(FR) permet de chiffrer et de d\303\251chiffrer toutes les donn\303\251es entr\303\251es en param\303\250tre le mot de passe demand\303\251 au d\303\251but est hash\303\251 puis sert de graine pour le PRNG le PRNG permet de fournir une cl\303\251 unique \303\251gale \303\240 la longueur du fichier \303\240 coder. La cl\303\251 unique subit un xor avec le mot de passe (le mot de passe est r\303\251p\303\251t\303\251 autant de fois que n\303\251c\303\251ssaire). Le fichier subit un xor avec cette cl\303\251 Puis un brouilleur est utilis\303\251, il m\303\251lange la table des caract\303\250res (ascii) en utilisant le PRNG ou en utilisant le keyFile fourni.\n\t(EN) Can crypt and decrypt any data given in argument. The password asked is hashed to be used as a seed for the PRNG. The PRNG gives a unique key which has the same length as the source file. The key is xored with the password (the password is repeated as long as necessary). The file is then xored with this new key, then a scrambler is used. It scrambles the ascii table using the PRNG or the keyFile given\n\nOPTIONS\n\tthe options are as follows:\n\n\t-h | --help\tfurther help.\n\n\t-s | --standard\tput the scrambler on off.\n\n\t-i | --inverted\tinverts the coding/decoding process, first it xors then it scrambles.\n\n\tKEYFILE    \tthe path to a file which will be used to scramble the substitution's tables and choose in which order they will be used instead of the PRNG only (starting at 2.5 ko for the keyfile is great, however not interesting to be too heavy) \n\nEXIT STATUS\n\tthe %s program exits 0 on success, and anything else if an error occurs.\n\nEXAMPLES\n\tthe command:\t%s file1\n\n\tlets you choose between crypting or decrypting then it will prompt for a password that crypt/decrypt file1 as xfile1 in the same folder, file1 is not modified.\n\n\tthe command:\t%s file2 keyfile1\n\n\tlets you choose between crypting or decrypting, will prompt for the password that crypt/decrypt file2, uses keyfile1 to generate the scrambler then crypt/decrypt file2 as file2x in the same folder, file2 is not modified.\n\n\tthe command:\t%s file3 -s\n\n\tlets you choose between crypting or decrypting, will prompt for a password that crypt/decrypt the file without using the scrambler, resulting in using the unique key only.\n"

L_.str.34:                              ## @.str.34
	.asciz	"Version : 2.3\nUsage : %s [-h | --help] FILE [-s | --standard | -i | --inverted] [KEYFILE]\nOptions :\n  -h --help :\t\tfurther help\n  -s --standard :\tput the scrambler off\n  -i --inverted :\tinverts the coding/decoding process\n  KEYFILE :\t\tpath to a keyfile that scrambles the substitution's tables and choose they order instead of the PRNG only\n"
	.asciz	"scrambling substitution's tables..."
	.asciz	"starting encryption..."
	.align	4                       ## @str.37
L_str.37:
	.asciz	"starting decryption..."
	.asciz	"error: file's path is not correct, one or several directories and or file are missing"
	.asciz	"Done                                                                  "
	.asciz	"\rregrouping the folder in one file using tar... Done          "
	.asciz	"\nerror: unable to tar your file"

	.align	4                       ## @str.48
L_str.48:
L_str.49:                               ## @str.49
	.align	4                       ## @str.51
L_str.51:
	.align	4                       ## @str.52
L_str.52: