Aktuelle Zeit: 05.06.2020 17:02

Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]




Ein neues Thema erstellen Auf das Thema antworten  [ 7 Beiträge ] 
Autor Nachricht
 Betreff des Beitrags: SimpleAES (AES Vereinfachung)
BeitragVerfasst: 06.03.2013 17:54 
Offline

Registriert: 13.07.2008 10:05
Ich habe mich heute mal wieder etwas mit der AES Verschlüsselung in Pure Basic auseinandergesetzt, da ich verschlüsselte Daten mit einer Java Anwendung austauschen musste. Herausgekommen ist eine Vereinfachung die alles >= 1 Byte an Daten verarbeiten und einschließlich eines ordentlichen Padding verschlüsseln bzw. entschlüsseln kann. Außerdem wird der IV falls gewünscht automatisch generiert und vor die Daten gesetzt so dass man sich auch um den IV keine Sorgen mehr machen muss. Vielleicht kann ja noch jemand so eine Vereinfachung der AES Funktionen brauchen oder hat gute Ideen was man daran noch verbessern kann.

Edit1: 22.03.2014 Code umgebaut, zu einem Modul gemacht und um neue Funktionen zum verschlüsseln von Strings und Dateien erweitert.

Edit2: 29.03.2014 Modifikation des Beispiels. Außerdem SimpleAES.java hinzugefügt.
Download: SimpleAES.pb https://dl.dropboxusercontent.com/u/43570049/SimpleAES.pb (entspricht dem hier im Forum eingebetteten Code)
Download: SimpleAES.java https://dl.dropboxusercontent.com/u/43570049/SimpleAES.java (kompatible Java Version von SimpleAES [Work in progress])

Code:
; ----------------------------------------------------------------------
;- SimpleAES.pb
; ----------------------------------------------------------------------
; | Title:   | SimpleAES
; ----------------------------------------------------------------------
; | Author:  | Christian+
; ----------------------------------------------------------------------
; | Date:    | 2014-03-29
; ----------------------------------------------------------------------
; | Version: | 1.4
; ----------------------------------------------------------------------
; | URL:     | http://forums.purebasic.com/german/viewtopic.php?p=309907#p309907
; ----------------------------------------------------------------------

DeclareModule SimpleAES
 
  EnableExplicit
 
  ; ----------------------------------------------------------------------------
  ; Overview
  ; ----------------------------------------------------------------------------
  ; Declare.i SimpleAES_StartCipher(*Key, Mode.i = #PB_Cipher_Encode, *Options.SimpleAES_Config = 0)
  ; Declare.i SimpleAES_AddCipherBuffer(*Data, *InputMemory, InputSize.i, *OutputMemory, Finish.i = #False)
  ; Declare   SimpleAES_FinishCipher(*Data)
 
  ; Declare.i SimpleAES_CryptMemory(*Key, Mode.i, *Memory, Size.i = -1, *Options.SimpleAES_Config = 0)
 
  ; Declare.s SimpleAES_CryptString(*Key, Mode.i, String.s, Type.i = #PB_UTF8, *Options.SimpleAES_Config = 0)
 
  ; Declare.i SimpleAES_CryptFile(*Key, Mode.i, SourceFileName.s, NewFileName.s, *Procedure = 0, BlockSize.i = 0, *Options.SimpleAES_Config = 0)
 
  ; Declare.s SimpleAES_Base64Encoder(*Memory, Size.i = -1, Falgs.i = 0)
  ; Declare.i SimpleAES_Base64Decoder(Base64String.s)
  ; ----------------------------------------------------------------------------
 
  ; Default Anzahl an Bits für den Schlüssel (128 Bit, 192 Bit oder 256 Bit sind möglich!)
  Global DefaultBits = 128
 
  Enumeration
    #PKCS5Padding  ;Kompatibel mit Java (z.B.: "AES/CBC/PKCS5Padding")
    ;...
  EndEnumeration
 
  Structure SimpleAES_Config
    CipherMode.i  ; = #PB_Cipher_CBC
    Bits.i        ; = DefaultBits
    Padding.i     ; = #PKCS5Padding
    AttachIV.i    ; = #True
    CryptRandom.i ; = #False
    *IV           ; = 0
  EndStructure
 
  ; ----------------------------------------------------------------------------
  ; *Key -> "Ein Speicherbereich, welcher den Schlüssel enthält. (Schlüssel: 16 Byte bei 128 Bit; 24 Byte bei 192 Bit; 32 Byte bei 256 Bit)"
  ; Mode -> "#PB_Cipher_Encode oder #PB_Cipher_Decode"
  ; *Options -> "Struktur die für Fortgeschrittene zusätzliche Konfigurationsmöglichkeiten bietet."
  ; ----------------------------------------------------------------------------
  ; Rückgabewert: "SimpleAES Cipher Pointer"
  ; ----------------------------------------------------------------------------
  Declare.i SimpleAES_StartCipher(*Key, Mode.i = #PB_Cipher_Encode, *Options.SimpleAES_Config = 0)
 
  ; ----------------------------------------------------------------------------
  ; *Data -> "SimpleAES Cipher Pointer"
  ; *InputMemory -> "Eingabespeicherbereich"
  ; InputSize -> "Größe des Eingabespeicherbereich"
  ; *OutputMemory -> "Ausgabespeicherbereich (Wichtig: *OutputMemory muss 32 Byte größer als *InputMemory sein!)"
  ; Finish -> "#True um Ver/Entschlüsselung zu beenden und alle restlichen Daten in *OutputMemory zu schreiben (Wichtig für das Padding)."
  ; ----------------------------------------------------------------------------
  ; Rückgabewert: "Anzahl an Bytes die in *OutputMemory geschrieben wurden."
  ; ----------------------------------------------------------------------------
  Declare.i SimpleAES_AddCipherBuffer(*Data, *InputMemory, InputSize.i, *OutputMemory, Finish.i = #False)
 
  ; ----------------------------------------------------------------------------
  ; *Data -> "SimpleAES Cipher Pointer"
  ; ----------------------------------------------------------------------------
  Declare   SimpleAES_FinishCipher(*Data)
 
  ; ----------------------------------------------------------------------------
  ; *Key -> "Ein Speicherbereich, welcher den Schlüssel enthält. (Schlüssel: 16 Byte bei 128 Bit; 24 Byte bei 192 Bit; 32 Byte bei 256 Bit)"
  ; Mode -> "#PB_Cipher_Encode oder #PB_Cipher_Decode"
  ; *Memory -> "Eingabespeicherbereich"
  ; Size -> "Größe des Eingabespeicherbereich"
  ; *Options -> "Struktur die für Fortgeschrittene zusätzliche Konfigurationsmöglichkeiten bietet."
  ; ----------------------------------------------------------------------------
  ; Rückgabewert: "Pointer auf Speicherbereich mit den verschlüsselten Daten."
  ; ----------------------------------------------------------------------------
  Declare.i SimpleAES_CryptMemory(*Key, Mode.i, *Memory, Size.i = -1, *Options.SimpleAES_Config = 0)
 
  ; ----------------------------------------------------------------------------
  ; *Key -> "Ein Speicherbereich, welcher den Schlüssel enthält. (Schlüssel: 16 Byte bei 128 Bit; 24 Byte bei 192 Bit; 32 Byte bei 256 Bit)"
  ; Mode -> "#PB_Cipher_Encode oder #PB_Cipher_Decode"
  ; String -> "String der Verschlüsselt bzw. Entschlüsselt werden soll."
  ; Type -> "Codierung dir für den String verwendet werden soll (#PB_Ascii, #PB_UTF8 oder #PB_Unicode)"
  ; *Options -> "Struktur die für Fortgeschrittene zusätzliche Konfigurationsmöglichkeiten bietet."
  ; ----------------------------------------------------------------------------
  ; Rückgabewert: "Verschlüsselter bzw Entschlüsselter String."
  ; ----------------------------------------------------------------------------
  Declare.s SimpleAES_CryptString(*Key, Mode.i, String.s, Type.i = #PB_UTF8, *Options.SimpleAES_Config = 0)
 
  ; ----------------------------------------------------------------------------
  ; *Key -> "Ein Speicherbereich, welcher den Schlüssel enthält. (Schlüssel: 16 Byte bei 128 Bit; 24 Byte bei 192 Bit; 32 Byte bei 256 Bit)"
  ; Mode -> "#PB_Cipher_Encode oder #PB_Cipher_Decode"
  ; SourceFileName -> "Die Quelldatei"
  ; NewFileFileName -> "Die Zieldatei"
  ; *Procedure -> "Optinale Adresse einer Procedure mit zwei Int Parametern die nach jedem verarbeiteten Block an Daten aufgerufen wird."
  ; BlockSize -> Anzahl an Bytes die auf einmal gelesen / verarbeitet werden sollen.
  ; *Options -> "Struktur die für Fortgeschrittene zusätzliche Konfigurationsmöglichkeiten bietet."
  ; ----------------------------------------------------------------------------
  ; Rückgabewert: "#True bei Erfolg"
  ; ----------------------------------------------------------------------------
  Declare.i SimpleAES_CryptFile(*Key, Mode.i, SourceFileName.s, NewFileName.s, *Procedure = 0, BlockSize.i = 0, *Options.SimpleAES_Config = 0)
 
  ; ----------------------------------------------------------------------------
  ; *Memory -> "Eingabespeicherbereich"
  ; Size -> "Größe des Eingabespeicherbereich"
  ; ----------------------------------------------------------------------------
  ; Rückgabewert: "Base64 codierter String"
  ; ----------------------------------------------------------------------------
  Declare.s SimpleAES_Base64Encoder(*Memory, Size.i = -1, Falgs.i = 0)
 
  ; ----------------------------------------------------------------------------
  ; Base64String -> "Base64 codierter String"
  ; ----------------------------------------------------------------------------
  ; Rückgabewert: "Pointer auf Daten im Memory"
  ; ----------------------------------------------------------------------------
  Declare.i SimpleAES_Base64Decoder(Base64String.s)
 
EndDeclareModule

Module SimpleAES
 
  EnableExplicit
 
  Structure SimpleAES_CipherData
    *Key
    Mode.i
    Options.SimpleAES_Config
    Cipher.i
    MemorySize.i
    *Memory
  EndStructure 
 
  Procedure.i SimpleAES_StartCipher(*Key, Mode.i = #PB_Cipher_Encode, *Options.SimpleAES_Config = 0)
    Protected *Data.SimpleAES_CipherData = AllocateMemory(SizeOf(SimpleAES_CipherData))
    If *Options
      *Data\Options\CipherMode = *Options\CipherMode
      *Data\Options\Bits = *Options\Bits
      *Data\Options\Padding = *Options\Padding
      *Data\Options\AttachIV = *Options\AttachIV
      *Data\Options\CryptRandom = *Options\CryptRandom
      If *Options\IV <> 0 : *Data\Options\IV = AllocateMemory(16, #PB_Memory_NoClear) : CopyMemory(*Options\IV, *Data\Options\IV, 16) : EndIf
    Else
      *Data\Options\CipherMode = #PB_Cipher_CBC
      *Data\Options\Bits = DefaultBits
      *Data\Options\Padding = #PKCS5Padding
      *Data\Options\AttachIV = #True
      *Data\Options\CryptRandom = #False
    EndIf
    *Data\Key = AllocateMemory(*Data\Options\Bits/8, #PB_Memory_NoClear) : CopyMemory(*Key, *Data\Key, *Data\Options\Bits/8)
    *Data\Mode = Mode
    *Data\Memory = AllocateMemory(16, #PB_Memory_NoClear)
    ProcedureReturn *Data
  EndProcedure
 
  Procedure.i SimpleAES_AddCipherBuffer(*Data.SimpleAES_CipherData, *InputMemory, InputSize.i, *OutputMemory, Finish.i = #False)
    Protected *IV, OutputSize.i, Size.i, LeftOver.i, FillValue.i   
    If *Data\Cipher = 0
      Select *Data\Options\CipherMode
        Case #PB_Cipher_CBC
          If *Data\Mode = #PB_Cipher_Encode       
            If *Data\Options\IV <> 0
              CopyMemory(*Data\Options\IV, *Data\Memory, 16)
            Else
              If Not *Data\Options\CryptRandom Or Not CryptRandomData(*Data\Memory, 16) : RandomData(*Data\Memory, 16) : EndIf
            EndIf
            If *Data\Options\AttachIV
              CopyMemory(*Data\Memory, *OutputMemory, 16)
              OutputSize + 16
            EndIf
            *Data\Cipher = StartAESCipher(#PB_Any, *Data\Key, *Data\Options\Bits, *Data\Memory, *Data\Mode | *Data\Options\CipherMode)
          ElseIf *Data\Mode = #PB_Cipher_Decode
            If *Data\Options\IV <> 0
              CopyMemory(*Data\Options\IV, *Data\Memory, 16)
              *Data\Cipher = StartAESCipher(#PB_Any, *Data\Key, *Data\Options\Bits, *Data\Memory, *Data\Mode | *Data\Options\CipherMode)
            ElseIf InputSize >= 16
              CopyMemory(*InputMemory, *Data\Memory, 16)
              *InputMemory + 16
              InputSize - 16
              *Data\Cipher = StartAESCipher(#PB_Any, *Data\Key, *Data\Options\Bits, *Data\Memory, *Data\Mode | *Data\Options\CipherMode)
            ElseIf *Data\MemorySize + InputSize >= 16
              Size = 16-*Data\MemorySize
              CopyMemory(*InputMemory, *Data\Memory+*Data\MemorySize, Size)
              *InputMemory + Size
              InputSize - Size
              *Data\MemorySize = 0
              *Data\Cipher = StartAESCipher(#PB_Any, *Data\Key, *Data\Options\Bits, *Data\Memory, *Data\Mode | *Data\Options\CipherMode)
            EndIf       
          EndIf
        Case #PB_Cipher_ECB
          *Data\Cipher = StartAESCipher(#PB_Any, *Data\Key, *Data\Options\Bits, *Data\Memory, *Data\Mode | *Data\Options\CipherMode)
      EndSelect
    EndIf   
    If *Data\MemorySize + InputSize < 16     
      If InputSize > 0 : CopyMemory(*InputMemory, *Data\Memory+*Data\MemorySize, InputSize) : EndIf
      *Data\MemorySize + InputSize
    Else     
      If *Data\MemorySize > 0
        Size = 16-*Data\MemorySize
        CopyMemory(*InputMemory, *Data\Memory+*Data\MemorySize, Size)
        *InputMemory + Size
        InputSize - Size
        AddCipherBuffer(*Data\Cipher, *Data\Memory, *OutputMemory+OutputSize, 16)
        *Data\MemorySize = 0
        OutputSize + 16
      EndIf
      LeftOver = InputSize % 16
      InputSize - LeftOver
      If LeftOver > 0
        CopyMemory(*InputMemory+InputSize, *Data\Memory, LeftOver)
        *Data\MemorySize = LeftOver
      EndIf
      If InputSize > 0
        AddCipherBuffer(*Data\Cipher, *InputMemory, *OutputMemory+OutputSize, InputSize)
        OutputSize + InputSize
      EndIf     
    EndIf   
    If Finish
      Select *Data\Options\Padding
        Case #PKCS5Padding
          If *Data\Mode = #PB_Cipher_Encode
            FillValue = 16 - *Data\MemorySize
            FillMemory(*Data\Memory+*Data\MemorySize, FillValue, FillValue, #PB_Byte)
            AddCipherBuffer(*Data\Cipher, *Data\Memory, *OutputMemory+OutputSize, 16)
            OutputSize + 16
          EndIf
          If *Data\Mode = #PB_Cipher_Decode
            OutputSize - PeekA(*OutputMemory+OutputSize-1)
          EndIf
          *Data\MemorySize = 0
      EndSelect
    EndIf   
    ProcedureReturn OutputSize
  EndProcedure
 
  Procedure SimpleAES_FinishCipher(*Data.SimpleAES_CipherData)
    FinishCipher(*Data\Cipher)
    FreeMemory(*Data\Key)
    If *Data\Options\IV <> 0 : FreeMemory(*Data\Options\IV) : EndIf
    FreeMemory(*Data\Memory)
    FreeMemory(*Data)
  EndProcedure
 
  Procedure.i SimpleAES_CryptMemory(*Key, Mode.i, *Memory, Size.i = -1, *Options.SimpleAES_Config = 0)
    Protected Cipher.i, NewSize, *NewMemory
    If Size = -1 : Size = MemorySize(*Memory) : EndIf       
    *NewMemory = AllocateMemory(Size + 32, #PB_Memory_NoClear)   
    Cipher = SimpleAES_StartCipher(*Key, Mode, *Options)
    NewSize = SimpleAES_AddCipherBuffer(Cipher, *Memory, Size, *NewMemory, #True)
    SimpleAES_FinishCipher(Cipher)   
    ReAllocateMemory(*NewMemory, NewSize)
    ProcedureReturn *NewMemory
  EndProcedure
 
  Procedure.s SimpleAES_CryptString(*Key, Mode.i, String.s, Type.i = #PB_UTF8, *Options.SimpleAES_Config = 0)
    Protected Cipher.i, Size, *Memory, NewSize, *NewMemory, ResultString.s = ""       
    If Mode = #PB_Cipher_Encode   
      Size = StringByteLength(String, Type)
      *Memory = AllocateMemory(Size + SizeOf(Character), #PB_Memory_NoClear)
      PokeS(*Memory, String, -1, Type)
    Else
      *Memory = SimpleAES_Base64Decoder(String)
      Size = MemorySize(*Memory)
    EndIf   
    *NewMemory = AllocateMemory(Size + 32 + SizeOf(Character), #PB_Memory_NoClear)   
    Cipher = SimpleAES_StartCipher(*Key, Mode, *Options)
    NewSize = SimpleAES_AddCipherBuffer(Cipher, *Memory, Size, *NewMemory, #True)
    SimpleAES_FinishCipher(Cipher)   
    If Mode = #PB_Cipher_Encode   
      ResultString = SimpleAES_Base64Encoder(*NewMemory, NewSize)
    Else     
      PokeC(*NewMemory + NewSize, 0)
      If NewSize > 0 : ResultString = PeekS(*NewMemory, NewSize, Type) : EndIf
    EndIf   
    FreeMemory(*Memory)
    FreeMemory(*NewMemory)     
    ProcedureReturn ResultString
  EndProcedure
 
  Procedure.i SimpleAES_CryptFile(*Key, Mode.i, SourceFileName.s, NewFileName.s, *Procedure = 0, BlockSize.i = 0, *Options.SimpleAES_Config = 0)
    Protected Cipher.i, SourceFile.i, NewFile.i, SourceSize.i, Size.i, *SourceMemory, *NewMemory, Cancel.i, NewBlockSize.i, Status.i
    If BlockSize <= 0 : BlockSize = 16 * 1024 * 1024 : EndIf
    Cipher = SimpleAES_StartCipher(*Key, Mode, *Options)
    SourceFile = ReadFile(#PB_Any, SourceFileName)
    If SourceFile
      NewFile = CreateFile(#PB_Any, NewFileName)     
      If NewFile
        SourceSize = Lof(SourceFile)
        Size = SourceSize
        *SourceMemory = AllocateMemory(BlockSize, #PB_Memory_NoClear)
        *NewMemory = AllocateMemory(BlockSize + 32, #PB_Memory_NoClear)
        While Size > 0
          If *Procedure
            Cancel = CallFunctionFast(*Procedure, SourceSize - Size, SourceSize)
          EndIf
          If Cancel
            CloseFile(SourceFile)
            CloseFile(NewFile)
            DeleteFile(NewFileName)
            SimpleAES_FinishCipher(Cipher)
            If *Procedure
              CallFunctionFast(*Procedure, 0, 0)
            EndIf           
            ProcedureReturn #False
          EndIf
          If Size <= BlockSize
            ReadData(SourceFile, *SourceMemory, Size)
            NewBlockSize = SimpleAES_AddCipherBuffer(Cipher, *SourceMemory, Size, *NewMemory, #True)
            Status = #True
          Else
            ReadData(SourceFile, *SourceMemory, BlockSize)
            NewBlockSize = SimpleAES_AddCipherBuffer(Cipher, *SourceMemory, BlockSize, *NewMemory, #False)
          EndIf
          WriteData(NewFile, *NewMemory, NewBlockSize)
          Size - BlockSize
        Wend
        CloseFile(NewFile)
      EndIf
      CloseFile(SourceFile)
    EndIf
    SimpleAES_FinishCipher(Cipher)
    If *Procedure
      If status
        CallFunctionFast(*Procedure, SourceSize, SourceSize)
      Else
        CallFunctionFast(*Procedure, -1, -1)
      EndIf
    EndIf
    ProcedureReturn Status
  EndProcedure
 
  Procedure.s SimpleAES_Base64Encoder(*Memory, Size.i = -1, Flags = 0)
    Protected Base64Size.i, *Base64, Base64String.s
    If Size = -1 : Size = MemorySize(*Memory) : EndIf
    Base64Size = 64.0 + Size * 1.35
    *Base64 = AllocateMemory(Base64Size, #PB_Memory_NoClear)
    Base64Size = Base64Encoder(*Memory, Size, *Base64, Base64Size, Flags)
    Base64String = PeekS(*Base64, Base64Size, #PB_Ascii)
    FreeMemory(*Base64)
    ProcedureReturn Base64String
  EndProcedure
 
  Procedure.i SimpleAES_Base64Decoder(Base64String.s)
    Protected Base64Size.i, *Base64, *Memory, Size.i
    Base64Size = StringByteLength(Base64String, #PB_Ascii)
    *Base64 = AllocateMemory(Base64Size + 1, #PB_Memory_NoClear)
    PokeS(*Base64, Base64String, Base64Size, #PB_Ascii)
    Size = Base64Size + 64
    *Memory = AllocateMemory(Size, #PB_Memory_NoClear)
    Size = Base64Decoder(*Base64, Base64Size, *Memory, Size)
    FreeMemory(*Base64)
    ReAllocateMemory(*Memory, Size)
    ProcedureReturn *Memory
  EndProcedure

EndModule

;- Beispiel
CompilerIf #PB_Compiler_IsMainFile
 
  EnableExplicit
 
  Procedure.i ConvertHexToBin(String.s)
    Protected Index.i, Len.i = Len(String), *DestMemory = AllocateMemory(Len / 2)
    For Index = 1 To Len Step 2
      PokeA(*DestMemory + (Index - 1) / 2, Val("$" + Mid(String, Index, 2)))
    Next
    ProcedureReturn *DestMemory
  EndProcedure
 
  Procedure.i Create128BitMD5HashKey(Password.s)
    Protected *Memory, HashString.s
    *Memory = AllocateMemory(StringByteLength(Password, #PB_UTF8)+SizeOf(Character))
    PokeS(*Memory, Password, -1, #PB_UTF8)
    HashString = MD5Fingerprint(*Memory, StringByteLength(Password, #PB_UTF8))
    FreeMemory(*Memory)
    ProcedureReturn ConvertHexToBin(HashString)
  EndProcedure
 
  UseModule SimpleAES 
 
  Define *Key = Create128BitMD5HashKey("MyPassword123")
 
  ; String Test
  Debug "" : Debug "String Test"
 
  Define SourceString.s, DecodedString.s, EncodedString.s
 
  SourceString = "Hallo, dies ist ein Test des SimpleAES Moduls für Strings."
  Debug "SourceString: " + SourceString
 
  EncodedString = SimpleAES_CryptString(*Key, #PB_Cipher_Encode, SourceString)
  Debug "EncodedString: " + EncodedString
 
  DecodedString = SimpleAES_CryptString(*Key, #PB_Cipher_Decode, EncodedString)
  Debug "DecodedString: " + DecodedString
 
 
  ; Custom Options Test
  Debug "" : Debug "Custom Options Test"
 
  Define Options.SimpleAES_Config
  Options\CipherMode.i = #PB_Cipher_ECB
  Options\Bits = 256
  Options\Padding = #PKCS5Padding
 
  Debug "SourceString: " + SourceString
 
  EncodedString = SimpleAES_CryptString(?Key, #PB_Cipher_Encode, SourceString, #PB_Ascii, @Options)
  Debug "EncodedString: " + EncodedString
 
  DecodedString = SimpleAES_CryptString(?Key, #PB_Cipher_Decode, EncodedString, #PB_Ascii, @Options)
  Debug "DecodedString: " + DecodedString
 
 
  ; Memory Test
  Debug "" : Debug "Memory Test"
 
  Define EncodedMemory.i, DecodedMemory.i
 
  Debug "SourceString: " + SourceString
 
  EncodedMemory = SimpleAES_CryptMemory(*Key, #PB_Cipher_Encode, @SourceString, StringByteLength(SourceString) + SizeOf(Character)) 
 
  DecodedMemory = SimpleAES_CryptMemory(*Key, #PB_Cipher_Decode, EncodedMemory) 
 
  Debug "DecodedString: " + PeekS(DecodedMemory)
 
  ; File Test
  Debug "" : Debug "File Test"
 
  Define SourceFileName.s, EncodedFileName.s, DecodedFileName.s
 
  Procedure Progress(BytesProcessed, FileSize)
    If BytesProcessed = 0
      Debug "Start"
    EndIf
    Debug "(" + BytesProcessed + " / " + FileSize + ")"
    If BytesProcessed = FileSize
      Debug "End"
    EndIf
    If BytesProcessed = -1 And FileSize = -1
      Debug "Error"
    EndIf
  EndProcedure
 
  SourceFileName = OpenFileRequester("Bitte Datei zum Verschlüsseln auswählen", "", "Alle Dateien (*.*)|*.*", 0)
  If SourceFileName
   
    EncodedFileName = GetPathPart(SourceFileName) + GetFilePart(SourceFileName, #PB_FileSystem_NoExtension) + "(Encoded)." + GetExtensionPart(SourceFileName)
   
    SimpleAES_CryptFile(*Key, #PB_Cipher_Encode, SourceFileName, EncodedFileName, @Progress())
   
    DecodedFileName = GetPathPart(SourceFileName) + GetFilePart(SourceFileName, #PB_FileSystem_NoExtension) + "(Decoded)." + GetExtensionPart(SourceFileName)
   
    SimpleAES_CryptFile(*Key, #PB_Cipher_Decode, EncodedFileName, DecodedFileName, @Progress())
   
  EndIf
 
  DataSection
    Key:
    Data.b $06 , $a9 , $21 , $40 , $36 , $b8 , $a2 , $5b , $51 , $2e , $03 , $d6 , $36 , $12 , $01 , $07, $06 , $a9 , $21 , $40 , $36 , $b8 , $a2 , $5b , $51 , $2e , $03 , $d6 , $36 , $12 , $01 , $07
  EndDataSection
 
CompilerEndIf

_________________
Windows 8.1 Pro 64Bit | AMD Phenom II X4 955 @ 3.2 GHz | 4GB RAM | NVIDIA GeForce GTX 660


Zuletzt geändert von Christian+ am 29.03.2014 20:30, insgesamt 8-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: AESCryptor (AES Vereinfachung)
BeitragVerfasst: 06.03.2013 18:37 
Offline
Benutzeravatar

Registriert: 08.09.2004 00:57
Wohnort: Berlin
Christian+ hat geschrieben:
Code:
;*Key "Ein Speicherbereich, welcher den Schlüssel enthält. (Schlüssel: 16 Byte bei 128 Bit; 24 Byte bei 192 Bit; 32 Byte bei 256 Bit)"

Ich denke mal, dies soll der Initalisierungsverktor sein, der ist immer 16 Bytes lang!
Die Hilfe wurde bereits korrigiert, aber nur unter AESEncoder(), unter AESDecoder() steht es immer noch falsch,
sowie in den älteren Hilfen:
AESEncoder() hat geschrieben:
Der InitialisierungsVektor ist ein zufälliger Datenblock, welcher für das Initialisieren der Verschlüsselung verwendet wird, um ein Knacken beim Dekodieren zu verhindern (wird nur bei Verwendung des #PB_Cipher_CBC Modus benötigt). Der InitialisierungsVektor ist immer 16 Bytes lang.


Gruß
Thomas

_________________
PureBasic 5.71 | SpiderBasic 2.30 | Windows 10 Pro (x64) | Linux Mint 19.3 (x64)
Nutella hat nur sehr wenig Vitamine. Deswegen muss man davon relativ viel essen.
Bild


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: AESCryptor (AES Vereinfachung)
BeitragVerfasst: 06.03.2013 18:38 
Offline

Registriert: 31.12.2012 15:29
sieht interresant aus :allright:
Allerdings hat es noch einen kleinen bug (zumindest was ich bisher sehe).
Und zwar kann es passieren das CreateSimpleKey() zuviel speicher überschriebt


Code:
mem = AllocateMemory(1000)

Text$= "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
Debug PokeS(mem, Text$,256 / 8,  #PB_UTF8)

Text$= "ääääääääääääääääääääääääääääääääääääääääää"
Debug PokeS(mem, Text$,256 / 8,  #PB_UTF8)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: AESCryptor (AES Vereinfachung)
BeitragVerfasst: 06.03.2013 19:43 
Offline

Registriert: 13.07.2008 10:05
@ts-soft
Ja der IV ist immer 16 Byte da AES ja eine Blockgröße von 16 Byte hat in dem Fall passt es aber weil es ja der Schlüssel ist und der ist abhängig davon ob mit 128, 192 oder 256 Byte verschlüsselt wird. Den IV generiere ich ja automatisch es sein den der optimale Parameter *IV wird genutzt.

@BlackFish danke für den Hinweis werde um das Problem zu umgehen da auf #PB_Ascii umsteigen habe die Methode schnell noch am Ende zum einfachen Testen hinzugefügt und ist für den Praxiseinsatz sowieso nicht wirklich sicher genug. In 99% der Fälle wird man den Key sowieso über einen Hash des Passworts erzeugen oder sicher ausgetauschte komplett zufällig generierte Keys verwenden. SHA-256 würde sich anbieten verwende ich selbst habe davon aber keinen Pure Basic Code den ich einfach so hier einfügen kann.

Edit:
So jetzt habe ich mal ein SHA256 implementiert hoffentlich auf die schnelle ohne Fehler ^^
http://www.purebasic.fr/german/viewtopic.php?f=8&t=26480

_________________
Windows 8.1 Pro 64Bit | AMD Phenom II X4 955 @ 3.2 GHz | 4GB RAM | NVIDIA GeForce GTX 660


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: SimpleAES (AES Vereinfachung)
BeitragVerfasst: 22.03.2014 14:40 
Offline

Registriert: 13.07.2008 10:05
Da mein hier veröffentlichter Code schon etwas veraltet war habe ich ihn nun durch eine neue als Modul aufgebaute Variante mit mehr Funktionen ersetzt. Vielleicht hilft es ja mal jemand weiter wenn er sich mit dem Thema beschäftigt.

_________________
Windows 8.1 Pro 64Bit | AMD Phenom II X4 955 @ 3.2 GHz | 4GB RAM | NVIDIA GeForce GTX 660


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: SimpleAES (AES Vereinfachung)
BeitragVerfasst: 22.03.2014 15:02 
Offline
Benutzeravatar

Registriert: 08.09.2004 00:57
Wohnort: Berlin
:allright:
Gefällt mir, wird mir wohl viel Arbeit sparen, sobald ich es brauche.
Hab es jetzt aber nur überflogen, macht nen guten Eindruck!

Gruß
Thomas

_________________
PureBasic 5.71 | SpiderBasic 2.30 | Windows 10 Pro (x64) | Linux Mint 19.3 (x64)
Nutella hat nur sehr wenig Vitamine. Deswegen muss man davon relativ viel essen.
Bild


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: SimpleAES (AES Vereinfachung)
BeitragVerfasst: 12.03.2020 16:42 
Offline
Benutzeravatar

Registriert: 20.04.2006 09:50
Im englischen Forum gibt es einen Thread zu dieser lib und es wurde gebeten hier im deutschen Forum einmal darauf hinzuweisen.
https://www.purebasic.fr/english/viewtopic.php?f=13&t=74853
(deepl translated)
Zitat:
Hallo, ich möchte die Lösung für einen Fehler im simpleAES-Modul mitteilen, der mich seit Tagen blockiert hat :evil:
Ich kann den Thread für dieses Modul im Forum nicht finden, deshalb eröffne ich einen neuen.

Die Lösung besteht einfach darin, zwei ReAllocateMemory-Zeilen zu korrigieren, die die Zielvariable nicht verwendet haben, so dass, wenn das Ergebnis ein größerer Speicherblock war, alles beschädigt wird und das Programm ohne offensichtlichen Fehler beendet wird.

Dies sind die beiden Prozeduren, bei denen ReAllocateMemory die Zielvariable am Anfang nicht hatte:

[...]

Übersetzt mit http://www.DeepL.com/Translator (kostenlose Version)

_________________
my pb stuff..
Bild..jedenfalls war das mal so.


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 7 Beiträge ] 

Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 5 Gäste


Sie dürfen keine neuen Themen in diesem Forum erstellen.
Sie dürfen keine Antworten zu Themen in diesem Forum erstellen.
Sie dürfen Ihre Beiträge in diesem Forum nicht ändern.
Sie dürfen Ihre Beiträge in diesem Forum nicht löschen.

Suche nach:
Gehe zu:  

 


Powered by phpBB © 2008 phpBB Group | Deutsche Übersetzung durch phpBB.de
subSilver+ theme by Canver Software, sponsor Sanal Modifiye