Table of contents
 Encryption and Decryption in Cryptography
 Popular Cryptographic Methods
 Hashing in Cryptography
 Difference Between DataatRest and DatainTransit Cryptography
 Finding the Cryptography Algorithm from Encrypted Text
 Scenario: Received Encrypted Text
 Arithmetic and Logic Operations
 Compression and Decompression Techniques
 Block and Stream Ciphers
 Hashing Algorithms and Checksum Methods
 1. MD2
 2. MD4
 3. MD5
 4. MD6
 5. SHA0
 6. SHA1
 7. SHA2
 8. SHA3
 9. SM3
 10. Keccak
 11. Shake
 12. RIPEMD
 13. HAS160
 14. Whirlpool
 15. Snefru
 16. BLAKE2s
 17. GOST Hash
 18. Streebog
 19. SSDEEP
 20. СТРН
 21. Compare SSDEEP Hashes
 22. Compare СТРН Hashes
 23. HMAC
 24. СМАС (SMAS)
 25. Bcrypt
 26. Bcrypt Compare
 27. Bcrypt Parse
 28. Argon2
 29. Argon2 Compare
 30. Scrypt
 31. NT Hash
 32. LM Hash
 33. MurmurHash3
 34. Fletcher8 Checksum
 35. Fletcher16 Checksum
 36. Fletcher32 Checksum
 37. Fletcher64 Checksum
 38. Adler32 Checksum
 39. Luhn Checksum
 40. CRC8 Checksum
 41. CRC16 Checksum
 42. CRC32 Checksum
 43. TCP/IP Checksum
 Technical Analysis of Cryptographic Operations
 1. Public Key
 2. Parse X.509 Certificate
 3. Parse ASN.1 Hex String
 4. PEM to Hex
 5. Hex to PEM
 6. Hex to Object Identifier
 7. Object Identifier to Hex
 8. PEM to JWK
 9. JWK to PEM
 10. Generate PGP Key Pair
 11. PGP Encrypt
 12. PGP Decrypt
 13. PGP Verify
 14. PGP Encrypt and Sign
 15. PGP Decrypt and Verify
 16. Generate RSA Key Pair
 17. RSA Sign
 18. RSA Verify
 19. RSA Encrypt
 20. RSA Decrypt
 21. Generate ECDSA Key Pair
 22. ECDSA Signature Conversion
 23. ECDSA Sign
 24. ECDSA Verify
 25. Parse SSH Host Key
 26. Parse CSR
 27. Public Key from Certificate
 28. Public Key from Private Key
 Data Format Conversion Algorithms
 1. To Hexdump
 2. From Hexdump
 3. To Hex
 4. From Hex
 5. To Charcode
 6. From Charcode
 7. To Decimal
 8. From Decimal
 9. To Float
 10. From Float
 11. To Binary
 12. From Binary
 13. To Octal
 14. From Octal
 15. To Base32
 16. From Base32
 17. To Base45
 18. From Base45
 19. To Base58
 20. From Base58
 21. To Base62
 22. From Base62
 23. To Base64
 24. From Base64
 25. Show Base64 Offsets
 26. To Base92
 27. From Base92
 28. To Base85
 29. From Base85
 30. To Base
 31. From Base
 32. To BCD
 33. From BCD
 34. To HTML Entity
 35. From HTML Entity
 36. URL Encode
 37. URL Decode
 38. Escape Unicode Characters
 39. Unescape Unicode Characters
 40. Normalize Unicode
 41. To Quoted Printable
 42. From Quoted Printable
 43. To Punycode
 44. From Punycode
 45. AMF Encode
 46. AMF Decode
 47. To Hex Content
 48. From Hex Content
 49. PEM to Hex
 50. Hex to PEM
 51. Parse ASN.1 Hex String
 52. Change IP Format
 53. Encode Text
 54. Decode Text
 55. Text Encoding Brute Force
 56. Swap Endianness
 57. To MessagePack
 58. From MessagePack
 59. To Braille
 60. From Braille
 61. Parse TLV
 62. CSV to JSON
 63. JSON to CSV
 64. Avro to JSON
 65. CBOR Encode
 66. CBOR Decode
 67. Caret/Mdecode
 68. Rison Encode
 69. Rison Decode
Cryptography, the art of securing information, is foundational in the world of cybersecurity and hacking. It involves various methods and techniques to convert readable data into an unreadable format, known as ciphertext, to protect sensitive information from unauthorized access. One of the most widely used cryptographic methods is symmetric encryption, where a single key is used for both encryption and decryption. Examples include AES (Advanced Encryption Standard) and DES (Data Encryption Standard). Symmetric encryption is fast and efficient, making it ideal for encrypting large volumes of data. However, the main challenge lies in securely sharing the key between the communicating parties.
In contrast, asymmetric encryption uses a pair of keys: a public key for encryption and a private key for decryption. This method, utilized in protocols like RSA (RivestShamirAdleman) and ECC (Elliptic Curve Cryptography), enhances security by eliminating the need for key exchange. Asymmetric encryption is typically used for securing data transmissions, digital signatures, and ensuring the authenticity of messages. However, it is slower than symmetric encryption and is often combined with symmetric encryption in practical applications to optimize both security and performance. Cryptographic hashing, another vital method, generates a fixedsize hash value from data, providing integrity checks and playing a crucial role in password storage, digital signatures, and blockchain technology.
Encryption and Decryption in Cryptography
Encryption and decryption are fundamental processes in cryptography, ensuring the confidentiality of data by transforming readable information (plaintext) into an unreadable format (ciphertext) and vice versa. Symmetric encryption uses the same key for both encryption and decryption, offering speed and efficiency, while asymmetric encryption employs a pair of keys (public and private) to enhance security, albeit at a performance cost. These techniques are vital for secure communication, data protection, and authentication in various digital applications.
Popular Cryptographic Methods
ID  Method  Description  Type  Usage  Known Attacks 
1  AES  Advanced Encryption Standard; widely used symmetric key encryption standard.  Symmetric  Data encryption, VPNs, wireless security  Sidechannel attacks 
2  RSA  RivestShamirAdleman; popular asymmetric encryption algorithm based on integer factorization.  Asymmetric  Secure data transmission, digital signatures  Timing attacks, padding oracle attacks 
3  SHA256  Secure Hash Algorithm 256bit; part of the SHA2 family, producing a 256bit hash.  N/A (Hash Function)  Data integrity, blockchain technology  Collision attacks (theoretical) 
4  ECC  Elliptic Curve Cryptography; asymmetric encryption leveraging elliptic curves over finite fields.  Asymmetric  Mobile devices, SSL/TLS certificates  Sidechannel attacks 
5  3DES  Triple Data Encryption Standard; applies DES cipher algorithm three times to each data block.  Symmetric  Legacy systems, ATM encryption  Meetinthemiddle attacks 
6  Blowfish  Symmetrickey block cipher designed for fast performance.  Symmetric  Password hashing, file encryption  Key schedule attacks 
7  MD5  MessageDigest Algorithm 5; produces a 128bit hash value.  N/A (Hash Function)  Checksums, data integrity (legacy)  Collision attacks 
8  DiffieHellman  Key exchange method allowing secure sharing of keys over a public channel.  Asymmetric  VPNs, secure key exchange  Maninthemiddle attacks 
9  DES  Data Encryption Standard; an older symmetrickey method now considered insecure.  Symmetric  Legacy systems  Bruteforce attacks 
10  SHA1  Secure Hash Algorithm 1; produces a 160bit hash value.  N/A (Hash Function)  Data integrity (legacy)  Collision attacks 
Hashing in Cryptography
Hashing is a cryptographic technique that converts data into a fixedsize string of characters, which is typically a digest that uniquely represents the input. Hash functions are designed to be fast, deterministic, and irreversible, ensuring that even a small change in input produces a significantly different hash. This property makes hashing essential for verifying data integrity, securely storing passwords, and ensuring the authenticity of digital signatures. Commonly used hash functions include MD5, SHA1, and the SHA2 family, with SHA256 being particularly popular for its balance of security and efficiency.
ID  Hash Method  Description  Usage  Attacks 
1  SHA256  Part of the SHA2 family, producing a 256bit hash.  Blockchain, digital certificates, password hashing.  Resistant to known attacks; currently secure. 
2  SHA3  Latest SHA family, designed as a backup for SHA2.  Cryptographic applications, security protocols.  Resistant to known attacks; very secure. 
3  SHA1  Older hash method producing a 160bit hash.  Legacy systems, old digital certificates.  Vulnerable to collision attacks; not recommended for new use. 
4  MD5  Early hash function with a 128bit hash.  Checksums, legacy systems.  Vulnerable to collision attacks; broken for cryptographic use. 
5  RIPEMD160  A 160bit hash function from the RIPEMD family.  Cryptographic applications, digital signatures.  More secure than MD5 and SHA1, but less common. 
6  BLAKE2  A fast and secure hash function, designed as an alternative to MD5 and SHA.  General cryptographic applications, file verification.  Resistant to known attacks; highly secure. 
7  WHIRLPOOL  Produces a 512bit hash, based on a modified AES.  Archiving, file verification.  No known practical attacks; very secure. 
Difference Between DataatRest and DatainTransit Cryptography
DataatRest cryptography refers to the encryption methods used to protect data stored on devices or in databases. This includes data on hard drives, SSDs, and backup tapes. The goal is to prevent unauthorized access to stored data, even if the storage media are physically stolen or accessed. Common methods include fulldisk encryption (e.g., BitLocker, FileVault), database encryption, and filelevel encryption. The focus is on securing the data from breaches or unauthorized access while it is not actively being transmitted.
DatainTransit cryptography, on the other hand, protects data as it moves across networks, from one location to another, such as when data is being sent over the internet, between devices, or across internal networks. This includes email, file transfers, and web traffic. Techniques like TLS/SSL (used in HTTPS), VPNs, and endtoend encryption (e.g., in messaging apps) are common. The primary objective is to protect the data from interception, eavesdropping, or maninthemiddle attacks while it's being transmitted.
Finding the Cryptography Algorithm from Encrypted Text
Identifying the cryptographic algorithm used to encrypt a piece of ciphertext requires a methodical approach. This process involves analyzing the structure and characteristics of the ciphertext, performing pattern recognition, and applying various cryptographic techniques to deduce the algorithm. Below is a stepbystep guide, along with an ASCII mindmap and character review conditions.
StepbyStep Process:
Initial Ciphertext Analysis:
Character Set: Determine the type of characters used in the ciphertext (e.g., alphanumeric, symbols, binary).
Length: Check if the length is a multiple of common block sizes (e.g., 64, 128, 256 bits).
Base Encoding: Determine if the ciphertext is encoded in a format like Base64, Hexadecimal, etc.
Pattern and Structure Recognition:
Repetition Patterns: Identify repeating patterns or blocks which might indicate block ciphers or certain modes like ECB.
Entropy Assessment: Measure the randomness of the ciphertext. High entropy suggests strong encryption.
Algorithm Matching:
Hash Length Comparison: Compare the length and structure with known hash functions (e.g., MD5  128 bits, SHA256  256 bits).
Block Cipher Analysis: Consider the block size (e.g., 64 bits for DES, 128 bits for AES) and structure.
Frequency Analysis:
Character Frequency Distribution: Perform frequency analysis to detect nonrandom distributions, hinting at substitution ciphers or weak encryption.
Alphabetic Characters: Check if the ciphertext maintains a pattern similar to languagebased text, indicating possible simpler ciphers.
Test Decryption:
KnownPlaintext Attack: Use any known plaintext to attempt partial decryption, testing against different algorithms.
Brute Force/Dictionary Attacks: Apply brute force or dictionary attacks if possible, especially for weaker or simpler algorithms.
Utilize Cryptographic Tools:
 Cryptanalysis Tools: Employ cryptographic tools or libraries (e.g., Hashcat, John the Ripper) to automate algorithm identification and attack attempts.
++
 Finding Cryptography Algorithm 
++

V
++
 Initial Ciphertext Analysis 
  Character set 
  Length 
  Base encoding 
++

V
++
 Pattern and Structure Recognition
  Repetition patterns 
  Entropy assessment 
++

V
++
 Algorithm Matching 
  Hash length comparison 
  Block cipher analysis 
++

V
++
 Frequency Analysis 
  Character frequency 
  Alphabetic patterns 
++

V
++
 Test Decryption 
  Knownplaintext attack 
  Brute force/dictionary attacks 
++

V
++
 Utilize Cryptographic Tools 
  Cryptanalysis tools 
++
StepbyStep Character Review and Conditions:
Character Set Analysis:
Condition: If the ciphertext contains only hexadecimal characters (09, AF), it might be encoded or could indicate a hash function.
Condition: If the ciphertext is Base64 (alphanumeric +
/
,+
,=
), it suggests encoding often used after encryption.
Length and Block Size:
Condition: If the ciphertext length is a multiple of 64, 128, or 256 bits, it could be indicative of a block cipher like DES, 3DES, or AES.
Condition: If the ciphertext length is fixed and small (e.g., 128 or 256 bits), it might be a hash output (e.g., MD5, SHA256).
Repetition Patterns:
Condition: Repeating blocks every 8 or 16 characters might indicate ECB mode of a block cipher (e.g., AES in ECB mode).
Condition: Lack of repetition with consistent length might suggest CBC mode or another encryption mode that avoids patterns.
Entropy and Randomness:
Condition: If the ciphertext appears highly random with no discernible patterns, it likely involves a strong encryption algorithm.
Condition: Low entropy might suggest simpler or broken encryption methods, possibly vulnerable to certain attacks.
Character Frequency:
Condition: If frequency analysis shows a distribution similar to English text, it may suggest a substitution cipher or weak encryption.
Condition: Random or flat frequency distribution suggests a modern, strong encryption method.
Test Decryption:
Condition: If decryption with a common algorithm partially succeeds using known plaintext, the algorithm might be identified.
Condition: If bruteforce attempts on weak algorithms (like DES) succeed, the algorithm is likely one of those tested.
To make the process of identifying cryptographic algorithms more tangible, let's walk through a detailed example for each step in the context of a scenario where you receive a piece of encrypted text and need to determine the algorithm used.
Scenario: Received Encrypted Text
You receive the following encrypted text:
QmFzZTY0RW5jb2RlZFRleHQ=
You need to identify which cryptographic algorithm or method was used to create this ciphertext.
StepbyStep Example
Initial Ciphertext Analysis
Character Set:
Example: The text
QmFzZTY0RW5jb2RlZFRleHQ=
includes uppercase and lowercase letters, numbers, and special characters like=
.Condition: These characters suggest Base64 encoding, a common postencryption encoding method.
Length:
Example: The length of the ciphertext is 24 characters.
Condition: The length is not directly indicative of a specific block size, but since Base64 encodes in chunks, this length can help deduce the original plaintext size.
Base Encoding:
Example: Recognizing the
=
padding and character set, you identify this as Base64.Condition: Base64 is used to encode binary data in ASCII format, commonly seen after encryption.
Pattern and Structure Recognition
Repetition Patterns:
Example: No repetition of blocks is observed in the Base64encoded string.
Condition: If repetition existed, it might indicate a block cipher in ECB mode. The absence suggests either a nonrepeating pattern or that Base64 hides repetition in the underlying binary data.
Entropy Assessment:
Example: The encoded text appears random at a glance, but further entropy analysis is needed.
Condition: High entropy in the Base64encoded string hints at strong encryption in the underlying data.
Algorithm Matching
Hash Length Comparison:
Example: The Base64 string length of 24 characters translates to 18 bytes of binary data, which does not directly match standard hash lengths (e.g., MD5, SHA256).
Condition: This indicates it is likely not a hash function output but possibly a short message encrypted and encoded.
Block Cipher Analysis:
Example: Given no clear multiple of a common block size (e.g., 16 bytes for AES), it's challenging to match a block cipher directly.
Condition: The nonmatching block size suggests this might be a smaller data piece or a short plaintext encrypted with a block cipher and then encoded.
Frequency Analysis
Character Frequency Distribution:
Example: Since the text is Base64 encoded, normal frequency analysis on the encoded string won't be useful.
Condition: If the underlying data was a simple cipher, a noticeable pattern would emerge upon decoding.
Alphabetic Characters:
Example: Decoding
QmFzZTY0RW5jb2RlZFRleHQ=
givesBase64EncodedText
.Condition: This reveals that the text was not encrypted but simply encoded. If it were encrypted, decoding would yield nonreadable text.
Test Decryption
KnownPlaintext Attack:
Example: Suppose you expect the plaintext could be "Base64EncodedText". Decoding reveals this directly.
Condition: If a plaintext guess succeeds, it confirms the method (in this case, Base64 encoding).
Brute Force/Dictionary Attacks:
Example: If decoding fails, you might try known encryption algorithms (AES, DES) with typical passwords.
Condition: A successful decryption attempt would confirm the algorithm used.
Utilize Cryptographic Tools
Cryptanalysis Tools:
Example: Use tools like
openssl
to test decryptions, but after decoding the Base64, no encryption is needed in this case.Condition: If encryption were involved, tools like
Hashcat
could help crack weak passwords or known ciphertext patterns.
Arithmetic and Logic Operations
Arithmetic and logic operations are fundamental to computer science, mathematics, and cryptography. Below is an explanation of each operation, along with an example test case for clarity.
Set Operations
 Set Union
 Description: Combines all elements from two sets, removing duplicates.  Example:  Sets: A = {1, 2, 3}, B = {3, 4, 5}  Union: A ∪ B = {1, 2, 3, 4, 5} 2. Set Intersection
 Description: Yields elements common to both sets.  Example:  Sets: A = {1, 2, 3}, B = {3, 4, 5}  Intersection: A ∩ B = {3} 3. Set Difference
 Description: Elements in one set but not the other.  Example:  Sets: A = {1, 2, 3}, B = {3, 4, 5}  Difference: A  B = {1, 2} 4. Symmetric Difference
 Description: Elements in either set, but not in both.  Example:  Sets: A = {1, 2, 3}, B = {3, 4, 5}  Symmetric Difference: A Δ B = {1, 2, 4, 5} 5. Cartesian Product
 Description: All possible ordered pairs from two sets.  Example:  Sets: A = {1, 2}, B = {a, b}  Cartesian Product: A × B = {(1, a), (1, b), (2, a), (2, b)} 6. Power Set
 Description: The set of all subsets of a set.  Example:  Set: A = {1, 2}  Power Set: P(A) = {∅, {1}, {2}, {1, 2}}
Logic Operations
XOR (Exclusive OR)
Description: Outputs true when inputs differ.
Example:
Inputs: A = 1010, B = 1100
XOR Result: A ⊕ B = 0110
XOR Brute Force
Description: Testing possible keys in a bruteforce attack by XORing ciphertext with keys.
Example:
Ciphertext: C = 0110
Brute Force Keys: Key1 = 0011, Key2 = 1001, etc.
Result (Key1): C ⊕ Key1 = 0101
OR
Description: Outputs true if at least one input is true.
Example:
Inputs: A = 1010, B = 1100
OR Result: A  B = 1110
NOT
Description: Inverts the input.
Example:
Input: A = 1010
NOT Result: ¬A = 0101
AND
Description: Outputs true only if both inputs are true.
Example:
Inputs: A = 1010, B = 1100
AND Result: A & B = 1000
Arithmetic Operations
 ADD
 Description: Adds two numbers.  Example:  Inputs: A = 7, B = 3  Addition Result: A + B = 10 13. SUB (Subtract)
 Description: Subtracts one number from another.  Example:  Inputs: A = 7, B = 3  Subtraction Result: A  B = 4 14. Multiply
 Description: Multiplies two numbers.  Example:  Inputs: A = 7, B = 3  Multiplication Result: A * B = 21 15. Divide
 Description: Divides one number by another.  Example:  Inputs: A = 9, B = 3  Division Result: A / B = 3 16. Sum
 Description: Sums a list of numbers.  Example:  List: {1, 2, 3, 4}  Sum Result: 1 + 2 + 3 + 4 = 10 17. Subtract (List)
 Description: Subtracts all elements in a list from a starting value.  Example:  List: {10, 2, 3, 1}  Subtraction Result: 10  2  3  1 = 4 18. Mean
 Description: Average of a list of numbers.  Example:  List: {1, 2, 3, 4}  Mean Result: (1 + 2 + 3 + 4) / 4 = 2.5 19. Median
 Description: Middle value in a sorted list.  Example:  List: {1, 3, 2, 4}  Sorted List: {1, 2, 3, 4}  Median Result: Median = (2 + 3) / 2 = 2.5 20. Standard Deviation
 Description: Measures data spread relative to the mean.  Example:  List: {1, 2, 3, 4}  Mean: 2.5  Variance: ((12.5)² + (22.5)² + (32.5)² + (42.5)²) / 4 = 1.25  Standard Deviation: √1.25 = 1.118
Bitwise Operations
 Bit Shift Left
 Description: Shifts bits to the left, filling with 0s.  Example:  Input: A = 0011  Shift Left 1: A << 1 = 0110 22. Bit Shift Right
 Description: Shifts bits to the right, filling with 0s.  Example:  Input: A = 0011  Shift Right 1: A >> 1 = 0001 23. Rotate Left
 Description: Rotates bits to the left, wrapping around.  Example:  Input: A = 0011  Rotate Left 1: Rotate(A, 1) = 0110 24. Rotate Right
 Description: Rotates bits to the right, wrapping around.  Example:  Input: A = 0011  Rotate Right 1: Rotate(A, 1) = 1001
ROT Cipher Operations
 ROT13
 Description: Substitutes each letter with the one 13 places after it in the alphabet.  Example:  Input: "HELLO"  ROT13 Result: "URYYB" 26. ROT8000
 Description: A variant ROT cipher that rotates the character code by 8000 positions.  Example:  Input: "HELLO"  ROT8000 Result: "∀∃ℒℒΦ"
Compression and Decompression Techniques
Compression is the process of reducing the size of data, while decompression restores the data to its original size. Various algorithms and formats are used for different purposes, from efficient storage to fast access. Here’s an overview of each compression and decompression method with example test cases.
Compression and Decompression Methods
Compression
Description: General term for algorithms that reduce data size by encoding information more efficiently.
Example Test Case:
Input Data: "hello hello hello"
Compressed Output: "h2e2l6o3"
Raw Deflate
Description: Compresses data using the DEFLATE algorithm without adding headers or checksums.
Example Test Case:
Input Data: "hello hello hello"
Compressed Output: Binary stream, e.g.,
0x78 0x9c ...
Raw Inflate
Description: Decompresses data compressed with Raw Deflate.
Example Test Case:
Compressed Input: Binary stream, e.g.,
0x78 0x9c ...
Decompressed Output: "hello hello hello"
Zlib Deflate
Description: Compresses data using DEFLATE with zlib headers and checksums.
Example Test Case:
Input Data: "hello hello hello"
Compressed Output: Binary stream with zlib headers, e.g.,
0x78 0x9c ...
Zlib Inflate
Description: Decompresses data compressed with Zlib Deflate.
Example Test Case:
Compressed Input: Binary stream with zlib headers, e.g.,
0x78 0x9c ...
Decompressed Output: "hello hello hello"
Gzip
Description: Compresses data using the Gzip format, which includes headers and checksums.
Example Test Case:
Input Data: "hello hello hello"
Compressed Output: Gzip file, e.g.,
0x1f 0x8b ...
Gunzip
Description: Decompresses data compressed with Gzip.
Example Test Case:
Compressed Input: Gzip file, e.g.,
0x1f 0x8b ...
Decompressed Output: "hello hello hello"
Zip
Description: A file format that can compress multiple files and directories using various algorithms, often DEFLATE.
Example Test Case:
Input Files: file1.txt ("hello"), file2.txt ("world")
Compressed Output: ZIP file containing
file1.txt
andfile2.txt
Unzip
Description: Extracts files and directories from a ZIP archive.
Example Test Case:
Compressed Input: ZIP file containing
file1.txt
andfile2.txt
Decompressed Output:
file1.txt
("hello"),file2.txt
("world")
Bzip2 Compress
Description: Compresses data using the Bzip2 algorithm, which provides higher compression ratios than gzip.
Example Test Case:
Input Data: "hello hello hello"
Compressed Output: Bzip2 file, e.g.,
0x42 0x5a ...
Bzip2 Decompress
Description: Decompresses data compressed with Bzip2.
Example Test Case:
Compressed Input: Bzip2 file, e.g.,
0x42 0x5a ...
Decompressed Output: "hello hello hello"
Tar
Description: Archives multiple files into a single file without compression.
Example Test Case:
Input Files: file1.txt ("hello"), file2.txt ("world")
Archived Output: TAR file containing
file1.txt
andfile2.txt
Untar
Description: Extracts files from a TAR archive.
Example Test Case:
Archived Input: TAR file containing
file1.txt
andfile2.txt
Extracted Output:
file1.txt
("hello"),file2.txt
("world")
LZString Compress
Description: Compresses data using the LZbased algorithm for efficient text compression in JavaScript.
Example Test Case:
Input Data: "hello hello hello"
Compressed Output: LZString encoded string, e.g.,
"N4IgLgLgPgTgBAMwJYwM4TmArgWwM4BccwA2hYwFdoDGA0YwM4wDGA0IF5HgBccwAqkA9pqA1mFZxQJcANxBGiBQXkA1vH6AXJZLNFyzwXJoA==“
LZString Decompress
Description: Decompresses data compressed with LZString.
Example Test Case:
Compressed Input: LZString encoded string, e.g.,
"N4IgLgLgPgTgBAMwJYwM4TmArgWwM4BccwA2hYwFdoDGA0YwM4wDGA0IF5HgBccwAqkA9pqA1mFZxQJcANxBGiBQXkA1vH6AXJZLNFyzwXJoA==“
Decompressed Output: "hello hello hello"
LZMA Compress
Description: Compresses data using the LZMA algorithm for high compression ratios.
Example Test Case:
Input Data: "hello hello hello"
Compressed Output: LZMA file, e.g., binary stream starting with
0x5d 0x00 ...
LZMA Decompress
Description: Decompresses data compressed with LZMA.
Example Test Case:
Compressed Input: LZMA file, e.g., binary stream starting with
0x5d 0x00 ...
Decompressed Output: "hello hello hello"
LZ4 Compress
Description: Compresses data using the LZ4 algorithm, which provides fast compression and decompression.
Example Test Case:
Input Data: "hello hello hello"
Compressed Output: LZ4 file, e.g., binary stream with LZ4 headers.
LZ4 Decompress
Description: Decompresses data compressed with LZ4.
Example Test Case:
Compressed Input: LZ4 file, e.g., binary stream with LZ4 headers.
Decompressed Output: "hello hello hello"
LZNT1 Decompress
Description: Decompresses data compressed with the LZNT1 algorithm, used in NTFS and Windows.
Example Test Case:
Compressed Input: LZNT1 compressed data, e.g., binary stream with LZNT1 headers.
Decompressed Output: "hello hello hello"
AES Encrypt
Description: AES (Advanced Encryption Standard) encrypts data using a symmetric key. It supports key sizes of 128, 192, and 256 bits.
Example Test Case:
Input Data: "hello world", Key: "1234567890123456" (128bit key)
Encrypted Output: Binary data, e.g.,
0x3ad77bb40d7a3660a89ecaf32466ef97
AES Decrypt
Description: Decrypts data encrypted with AES.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x3ad77bb40d7a3660a89ecaf32466ef97
Decrypted Output: "hello world"
Blowfish Encrypt
Description: Blowfish is a symmetrickey block cipher with a variable key length from 32 to 448 bits.
Example Test Case:
Input Data: "hello world", Key: "mysecretkey"
Encrypted Output: Binary data, e.g.,
0x5f4dcc3b5aa765d61d8327deb882cf99
Blowfish Decrypt
Description: Decrypts data encrypted with Blowfish.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x5f4dcc3b5aa765d61d8327deb882cf99
Decrypted Output: "hello world"
DES Encrypt
Description: DES (Data Encryption Standard) encrypts data using a 56bit key. It is considered weak by modern standards but historically significant.
Example Test Case:
Input Data: "hello world", Key: "12345678" (64bit key)
Encrypted Output: Binary data, e.g.,
0x8d4b80f7e7f0bce0
DES Decrypt
Description: Decrypts data encrypted with DES.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x8d4b80f7e7f0bce0
Decrypted Output: "hello world"
Triple DES Encrypt
Description: Triple DES (3DES) applies DES three times for increased security.
Example Test Case:
Input Data: "hello world", Key: "123456781234567812345678" (192bit key)
Encrypted Output: Binary data, e.g.,
0x1d0d2f3e4f5e6f7f
Triple DES Decrypt
Description: Decrypts data encrypted with Triple DES.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x1d0d2f3e4f5e6f7f
Decrypted Output: "hello world"
Fernet Encrypt
Description: Fernet is a symmetric encryption method that includes authentication, ensuring both confidentiality and integrity.
Example Test Case:
Input Data: "hello world", Key: Fernet key
Encrypted Output: Encoded string, e.g.,
gAAAAABiAqFJ...
Fernet Decrypt
Description: Decrypts data encrypted with Fernet.
Example Test Case:
Encrypted Input: Encoded string, e.g.,
gAAAAABiAqFJ...
Decrypted Output: "hello world"
Block and Stream Ciphers
LS47 Encrypt
Description: LS47 is a symmetric block cipher.
Example Test Case:
Input Data: "hello world", Key: "somekey"
Encrypted Output: Binary data, e.g.,
0x8f9c5d1e...
LS47 Decrypt
Description: Decrypts data encrypted with LS47.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x8f9c5d1e...
Decrypted Output: "hello world"
RC2 Encrypt
Description: RC2 is a variablekey block cipher designed for encryption in the 1990s.
Example Test Case:
Input Data: "hello world", Key: "somekey"
Encrypted Output: Binary data, e.g.,
0x3c1d4e7f...
RC2 Decrypt
Description: Decrypts data encrypted with RC2.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x3c1d4e7f...
Decrypted Output: "hello world"
RC4
Description: RC4 is a stream cipher that uses a variablelength key.
Example Test Case:
Input Data: "hello world", Key: "secretkey"
Encrypted Output: Binary stream, e.g.,
0x3b 0x4d 0x6e ...
RC4 Drop
Description: The RC4 Drop method involves discarding the first few bytes of the keystream to prevent biases.
Example Test Case:
Input Data: "hello world", Key: "secretkey", Drop Bytes: 256
Encrypted Output: Binary stream after dropping initial bytes.
ChaCha
Description: ChaCha is a stream cipher designed to be a more secure and faster alternative to RC4.
Example Test Case:
Input Data: "hello world", Key: "supersecretkey", Nonce: 24byte value
Encrypted Output: Binary stream, e.g.,
0x2f 0x6c ...
Salsa20
Description: Salsa20 is a stream cipher designed for high performance and security.
Example Test Case:
Input Data: "hello world", Key: "secretkey", Nonce: 24byte value
Encrypted Output: Binary stream, e.g.,
0x4f 0x7c ...
XSalsa20
Description: XSalsa20 is an extended version of Salsa20 with a longer nonce.
Example Test Case:
Input Data: "hello world", Key: "secretkey", Nonce: 32byte value
Encrypted Output: Binary stream, e.g.,
0x5d 0x9e ...
Rabbit
Description: Rabbit is a stream cipher designed for fast encryption with a 128bit key.
Example Test Case:
Input Data: "hello world", Key: "key", Nonce: 16byte value
Encrypted Output: Binary stream, e.g.,
0x7a 0x5b ...
SM4 Encrypt
Description: SM4 is a block cipher used in China, similar to AES but with a fixed 128bit key.
Example Test Case:
Input Data: "hello world", Key: "1234567890123456"
Encrypted Output: Binary data, e.g.,
0x1a2b3c4d...
SM4 Decrypt
Description: Decrypts data encrypted with SM4.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x1a2b3c4d...
Decrypted Output: "hello world"
GOST Encrypt
Description: GOST is a Russian block cipher used for encryption with a 256bit key.
Example Test Case:
Input Data: "hello world", Key: "12345678901234567890123456789012"
Encrypted Output: Binary data, e.g.,
0x6f4e3c2b...
GOST Decrypt
Description: Decrypts data encrypted with GOST.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x6f4e3c2b...
Decrypted Output: "hello world"
GOST Sign
Description: Signs data using the GOST R 34.102012 signature algorithm.
Example Test Case:
Input Data: "hello world", Private Key: (private key value)
Signature Output: Signature, e.g., binary data
GOST Verify
Description: Verifies a GOST signature against data.
Example Test Case:
Input Data: "hello world", Signature: (signature), Public Key: (public key)
Verification Output: Valid/Invalid
GOST Key Wrap
Description: Encrypts a key using the GOST encryption standard.
Example Test Case:
Input Key: "key to be wrapped", Wrapping Key: "1234567890123456"
Wrapped Key Output: Binary data, e.g.,
0x8f9d...
GOST Key Unwrap
Description: Decrypts a key wrapped with GOST.
Example Test Case:
Wrapped Key Input: Binary data, e.g.,
0x8f9d...
, Unwrapping Key: "1234567890123456"Unwrapped Key Output: "key to be wrapped"
ROT13
Description: ROT13 is a simple letter substitution cipher that shifts letters by 13 positions in the alphabet.
Example Test Case:
Input Data: "hello world"
Encoded Output: "uryyb jbeyq"
ROT13 Brute Force
Description: Applying ROT13 repeatedly will return the original text due to its nature.
Example Test Case:
Input Data: "uryyb jbeyq"
Decoded Output: "hello world"
ROT47
Description: ROT47 shifts characters in the ASCII range from 33 to 126 by 47 positions.
Example Test Case:
Input Data: "hello world"
Encoded Output: "w6qq8 =@w8@"
ROT47 Brute Force
Description: Brute forcing ROT47 involves trying all possible shifts. ROT47 has a fixed shift of 47, so this is redundant.
Example Test Case:
Input Data: "w6qq8 =@w8@"
Decoded Output: "hello world"
ROT8000
Description: ROT8000 shifts characters in the extended ASCII set, not a standard rotation method.
Example Test Case:
Input Data: "hello world", Shift: 8000
Encoded Output: Based on extended ASCII character set.
XOR
Description: XOR is a bitwise operation that outputs true or 1 only when inputs differ.
Example Test Case:
Input Data 1: "hello", Input Data 2: "world"
XOR Output: Binary data result of XOR operation.
XOR Brute Force
Description: Brute forcing XOR encryption involves trying all possible keys.
Example Test Case:
Encrypted Input: XOR result, Possible Keys: Try all possible keys
Decrypted Output: Original data by matching patterns.
Vigenère Encode
Description: Vigenère cipher uses a keyword to shift letters in the plaintext.
Example Test Case:
Input Data: "hello world", Keyword: "key"
Encoded Output: "rijvs uyvjn"
XXTEA Encrypt
Description: XXTEA (eXtended TEA) is a block cipher designed to be secure and efficient for 64bit blocks.
Example Test Case:
Input Data: "hello world", Key: 16byte key
Encrypted Output: Binary data, e.g.,
0x7c 0x2f ...
XXTEA Decrypt
Description: Decrypts data encrypted with XXTEA.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x7c 0x2f ...
Decrypted Output: "hello world"
To Morse Code
Description: Converts text into Morse code.
Example Test Case:
Input Data: "hello"
Morse Code Output: ".... . ... ... "
From Morse Code
Description: Converts Morse code back into text.
Example Test Case:
Input Data: ".... . ... ... "
Text Output: "hello"
Bacon Cipher Encode
Description: Bacon Cipher encodes text using a binary system where each letter is replaced by a sequence of 5 binary digits.
Example Test Case:
Input Data: "hello"
Encoded Output: "AABAA ABBAA AABAB AABBA ABBAA"
Bacon Cipher Decode
Description: Decodes Bacon Cipher encoded text back to plain text.
Example Test Case:
Input Data: "AABAA ABBAA AABAB AABBA ABBAA"
Decoded Output: "hello"
Bifid Cipher Encode
Description: Bifid Cipher is a polygraphic substitution cipher combining transposition and substitution.
Example Test Case:
Input Data: "hello", Key: "keyword"
Encoded Output: "hfnos"
Bifid Cipher Decode
Description: Decodes text encoded with the Bifid Cipher.
Example Test Case:
Input Data: "hfnos", Key: "keyword"
Decoded Output: "hello"
Caesar Box Cipher
Description: A transposition cipher that arranges the text in a square grid and reads it out columnwise.
Example Test Case:
Input Data: "hello", Grid Size: 2x3
Encoded Output: "heol llo"
Affine Cipher Encode
Description: Affine Cipher is a type of monoalphabetic substitution cipher.
Example Test Case:
Input Data: "hello", Key (a,b): (5, 8)
Encoded Output: "xubbe"
Affine Cipher Decode
Description: Decodes text encoded with the Affine Cipher.
Example Test Case:
Input Data: "xubbe", Key (a,b): (5, 8)
Decoded Output: "hello"
A1Z26 Cipher Encode
Description: A simple substitution cipher that maps letters to their positions in the alphabet.
Example Test Case:
Input Data: "hello"
Encoded Output: "8 5 12 12 15"
A1Z26 Cipher Decode
Description: Decodes numbers back to text using the A1Z26 cipher.
Example Test Case:
Input Data: "8 5 12 12 15"
Decoded Output: "hello"
Rail Fence Cipher Encode
Description: A form of transposition cipher where text is written in a zigzag pattern across multiple rails.
Example Test Case:
Input Data: "hello", Rails: 2
Encoded Output: "hloel"
Rail Fence Cipher Decode
Description: Decodes text encoded with the Rail Fence Cipher.
Example Test Case:
Input Data: "hloel", Rails: 2
Decoded Output: "hello"
Atbash Cipher
Description: A substitution cipher where each letter of the alphabet is mapped to its reverse.
Example Test Case:
Input Data: "hello"
Encoded Output: "svool"
CipherSaber2 Encrypt
Description: A variant of the CipherSaber encryption system using a stream cipher.
Example Test Case:
Input Data: "hello world", Key: "key"
Encrypted Output: Binary data, e.g.,
0x3a 0x6b ...
CipherSaber2 Decrypt
Description: Decrypts data encrypted with CipherSaber2.
Example Test Case:
Encrypted Input: Binary data, e.g.,
0x3a 0x6b ...
Decrypted Output: "hello world"
Cetacean Cipher Encode
Description: A substitution cipher with a specific encoding scheme.
Example Test Case:
Input Data: "hello"
Encoded Output: Specific encoding, e.g., "h3ll0"
Cetacean Cipher Decode
Description: Decodes text encoded with the Cetacean Cipher.
Example Test Case:
Input Data: "h3ll0"
Decoded Output: "hello"
Substitute
Description: General term for substitution ciphers where each character in the plaintext is replaced by another character.
Example Test Case:
Input Data: "hello", Substitution: "ifmmp"
Encoded Output: "ifmmp"
Derive PBKDF2 Key
Description: PBKDF2 (PasswordBased Key Derivation Function 2) derives a key from a password and salt.
Example Test Case:
Input Data: Password: "password", Salt: "salt"
Derived Key: Binary data derived from PBKDF2 function.
Derive EVP Key
Description: EVP is a highlevel API used for cryptographic operations in OpenSSL.
Example Test Case:
Input Data: Password: "password", Salt: "salt"
Derived Key: Binary data derived from EVP key derivation.
Derive HKDF Key
Description: HKDF (HMACbased Key Derivation Function) derives a key from an initial key and optional context information.
Example Test Case:
Input Data: Key: "key", Info: "context"
Derived Key: Binary data derived from HKDF function.
Bcrypt
Description: Bcrypt is a password hashing function designed to be computationally intensive.
Example Test Case:
Input Data: Password: "password"
Hashed Output: Bcrypt hash, e.g.,
$2a$12$...
Scrypt
Description: Scrypt is a passwordbased key derivation function designed to be memoryhard.
Example Test Case:
Input Data: Password: "password", Salt: "salt"
Hashed Output: Scrypt hash, e.g.,
...
JWT Sign
Description: Signs a JSON Web Token (JWT) to ensure data integrity and authenticity.
Example Test Case:
Input Data: Payload: {"user": "Alice"}, Key: "secret"
Signed JWT: JWT token string with signature.
JWT Verify
Description: Verifies the signature of a JWT to ensure it hasn’t been tampered with.
Example Test Case:
Input Data: Signed JWT token, Key: "secret"
Verification Output: Valid/Invalid
JWT Decode
Description: Decodes a JWT to extract its payload and header.
Example Test Case:
Input Data: JWT token
Decoded Output: Payload, e.g., {"user": "Alice"}
Citrix CTX1 Encode
Description: Citrix CTX1 is a proprietary encoding scheme used in certain Citrix products.
Example Test Case:
Input Data: "hello world"
Encoded Output: Specific encoded format, e.g.,
encoded_data
Citrix CTX1 Decode
Description: Decodes data encoded with Citrix CTX1.
Example Test Case:
Input Data: Encoded data, e.g.,
encoded_data
Decoded Output: "hello world"
AES Key Wrap
Description: AES Key Wrap encrypts and wraps a key for secure storage or transmission.
Example Test Case:
Input Key: "key to be wrapped", Wrapping Key: "AES key"
Wrapped Key Output: Binary data, e.g.,
0x7f3b...
AES Key Unwrap
Description: Decrypts a key wrapped with AES Key Wrap.
Example Test Case:
Wrapped Key Input: Binary data, e.g.,
0x7f3b...
, Unwrapping Key: "AES key"Unwrapped Key Output: "key to be wrapped"
PseudoRandom Number Generator (PRNG)
Description: Generates a sequence of numbers that approximates random values using algorithms.
Example Test Case:
Input Seed: 12345
Generated Output: Sequence of pseudorandom numbers, e.g.,
34567, 67890...
Enigma
Description: The Enigma machine was used in WWII for encrypting messages using a complex rotor system.
Example Test Case:
Input Data: "hello", Rotor Settings: Example rotor positions
Encoded Output: Encoded text, e.g., "kfrvl"
Bombe
Description: Bombe was used to break Enigma ciphers by trying all possible settings.
Example Test Case:
Encrypted Data: "kfrvl"
Decoded Output: "hello" (after solving)
Multiple Bombe
Description: Multiple Bombes were used in parallel to solve Enigma codes more efficiently.
Example Test Case:
Encrypted Data: "kfrvl"
Decoded Output: "hello" (with enhanced speed)
Typex
Description: Typex was a cipher machine similar to Enigma used by the Germans.
Example Test Case:
Input Data: "hello", Machine Settings: Example settings
Encoded Output: Encoded text, e.g., "bvmop"
Lorenz
Description: The Lorenz SZ40/42 was a cipher machine used by the Germans, more complex than Enigma.
Example Test Case:
Input Data: "hello", Machine Settings: Example settings
Encoded Output: Encoded text, e.g., "zqljf"
Colossus
Description: Colossus was an early computer used to break Lorenz ciphers during WWII.
Example Test Case:
Encrypted Data: "zqljf"
Decoded Output: "hello"
SIGABA
Description: SIGABA was an American cipher machine used during WWII with a complex system.
Example Test Case:
Input Data: "hello", Machine Settings: Example settings
Encoded Output: Encoded text, e.g., "xkvrb"
Hashing Algorithms and Checksum Methods
Below is a detailed overview of various hashing algorithms and checksum methods with their technical analysis and example test cases.
1. MD2
Description: MD2 is a cryptographic hash function designed by Ronald Rivest. It produces a 128bit hash value.
Technical Analysis: Known for its simplicity but slower compared to modern algorithms. It is rarely used today due to vulnerabilities.
Example Test Case:
Input Data: "hello"
MD2 Hash Output:
04e0f4e3e32f0b9ecfa4d8efba6bb9b2
2. MD4
Description: MD4 is a cryptographic hash function designed by Ronald Rivest. It generates a 128bit hash value.
Technical Analysis: Vulnerable to collision attacks and is largely replaced by MD5 and more secure algorithms.
Example Test Case:
Input Data: "hello"
MD4 Hash Output:
d7a8fbb9c2c5d7e7f6a5a8b1b4f6e6b7
3. MD5
Description: MD5 produces a 128bit hash value and is widely used but has known vulnerabilities, including susceptibility to collision attacks.
Technical Analysis: Generally considered obsolete for cryptographic security due to its vulnerabilities but still used in nonsecurity contexts.
Example Test Case:
Input Data: "hello"
MD5 Hash Output:
5d41402abc4b2a76b9719d911017c592
4. MD6
Description: MD6 is a cryptographic hash function designed as a candidate for the SHA3 competition but is less known.
Technical Analysis: More secure than MD5 but not widely adopted.
Example Test Case:
Input Data: "hello"
MD6 Hash Output:
d1e1e2b8db8f0a44e8e3dff02dd4f24c
5. SHA0
Description: SHA0 was the original version of the SHA family, but it has been replaced due to vulnerabilities.
Technical Analysis: Outdated and insecure; superseded by SHA1 and later algorithms.
Example Test Case:
Input Data: "hello"
SHA0 Hash Output:
5d41402abc4b2a76b9719d911017c592
6. SHA1
Description: SHA1 produces a 160bit hash and is more secure than MD5 but still vulnerable to collision attacks.
Technical Analysis: Deprecated for most security purposes due to known vulnerabilities.
Example Test Case:
Input Data: "hello"
SHA1 Hash Output:
f5723d6dd55f7a8c05e9d3a1b670b823b5d4c07b
7. SHA2
Description: SHA2 encompasses multiple hash functions, including SHA224, SHA256, SHA384, and SHA512. It offers improved security over SHA1.
Technical Analysis: Widely used and recommended for cryptographic security.
Example Test Case:
Input Data: "hello"
SHA256 Hash Output:
2cf24dba5fb0a30e26e83b2ac5b0e8c5c234b8a1c3a32c9ddbf7e2c9148e1a8e
8. SHA3
Description: SHA3 is the latest member of the Secure Hash Algorithm family and provides additional security features.
Technical Analysis: Based on the Keccak algorithm, it is designed to resist different types of attacks.
Example Test Case:
Input Data: "hello"
SHA3256 Hash Output:
5d41402abc4b2a76b9719d911017c592cbf0b53fa3345e0d6058f6b706e0b46
9. SM3
Description: SM3 is a cryptographic hash function used in China and is similar to SHA256.
Technical Analysis: Used primarily in Chinese cryptographic applications.
Example Test Case:
Input Data: "hello"
SM3 Hash Output:
9e107d9d372bb6826bd81d3542d8d83e
10. Keccak
Description: Keccak is the basis for the SHA3 family of hash functions.
Technical Analysis: It uses a sponge construction and is designed to be resistant to a variety of cryptographic attacks.
Example Test Case:
Input Data: "hello"
Keccak256 Hash Output:
5d41402abc4b2a76b9719d911017c592cbf0b53fa3345e0d6058f6b706e0b46
11. Shake
Description: SHAKE is an extendableoutput function (XOF) from the SHA3 family.
Technical Analysis: Allows for variablelength output and is used in various cryptographic applications.
Example Test Case:
Input Data: "hello", Length: 256 bits
SHAKE256 Output: Variablelength hash based on input and length.
12. RIPEMD
Description: RIPEMD (RIPE Message Digest) is a family of cryptographic hash functions.
Technical Analysis: Offers several variants like RIPEMD160, which provides a 160bit hash.
Example Test Case:
Input Data: "hello"
RIPEMD160 Hash Output:
fcf8e46d0faed65b9dc7d4dcbb32f14f220a9aeb
13. HAS160
Description: HAS160 is a cryptographic hash function with a 160bit output.
Technical Analysis: It is considered less secure compared to modern algorithms like SHA2.
Example Test Case:
Input Data: "hello"
HAS160 Hash Output:
9d5e3f8e3e1ef5cb2c761b230953c5a6d7f41880
14. Whirlpool
Description: Whirlpool is a cryptographic hash function designed to provide high security.
Technical Analysis: Produces a 512bit hash and is used in various security applications.
Example Test Case:
Input Data: "hello"
Whirlpool Hash Output:
d8e8fca2dc0f896fd7cb4cb0031ba249
15. Snefru
Description: Snefru is an older hash function known for its simplicity.
Technical Analysis: Not widely used today due to better alternatives.
Example Test Case:
Input Data: "hello"
Snefru Hash Output:
b05f2b5ff6ef7604c6b8a6d68c96e1ec
16. BLAKE2s
Description: BLAKE2s is a cryptographic hash function that is faster than MD5, SHA1, and SHA2.
Technical Analysis: Provides strong security and performance.
Example Test Case:
Input Data: "hello"
BLAKE2s Hash Output:
b94d27b9934d3e08a52e52d7da7dabfa
17. GOST Hash
Description: A hash function used in Russian cryptographic applications.
Technical Analysis: Part of the Russian Federal Standard and used in various security contexts.
Example Test Case:
Input Data: "hello"
GOST Hash Output:
3c6f06d64f437b79de7810a6b4c7d34a
18. Streebog
Description: Streebog is the Russian cryptographic hash function based on the GOST R 34.112012 standard.
Technical Analysis: Designed for high security and used in Russian cryptographic applications.
Example Test Case:
Input Data: "hello"
Streebog Hash Output:
10c6e6db0e8e54b08b8b1ec829a4d9d5
19. SSDEEP
Description: SSDEEP is a contextsensitive hashing algorithm that creates hash values for fuzzy matching.
Technical Analysis: Useful for detecting similarities in files.
Example Test Case:
Input Data: "hello world"
SSDEEP Hash Output:
3:n1YcD5jC7dJhBz0F2L1H8nBFSzpNOp:..
20. СТРН
Description: СТРН (STRN) is a Russian hash function used for data integrity verification.
Technical Analysis: It is used in Russian cryptographic standards.
Example Test Case:
Input Data: "hello world"
СТРН Hash Output:
d3b07384d113edec49eaa6238ad5ff00
21. Compare SSDEEP Hashes
Description: Comparing SSDEEP hashes allows you to find similarities between files or data.
Example Test Case:
Input Data 1: "hello world", Input Data 2: "hello world!"
SSDEEP Hash Comparison: Shows a similarity percentage or distance.
22. Compare СТРН Hashes
Description: Comparing СТРН hashes involves checking data integrity and similarity.
Example Test Case:
Input Data 1: "hello world", Input Data 2: "hello world!"
СТРН Hash Comparison: Shows if hashes match or differ.
23. HMAC
Description: HMAC (Hashbased Message Authentication Code) combines a cryptographic hash function with a secret key.
Technical Analysis: Provides integrity and authentication for messages.
Example Test Case:
Input Data: "hello", Key: "key"
HMACSHA256 Output:
8d969eef6ecad3c29a3a629280e686cf
24. СМАС (SMAS)
Description: СМАС (SMAS) is a Russian cryptographic algorithm for message authentication.
Technical Analysis: Used in Russian cryptographic systems for integrity verification.
Example Test Case:
Input Data: "hello", Key: "key"
СМАС Output:
7d9d91b8a54f3120d72d8c2263f3caa2
25. Bcrypt
Description: Bcrypt is a password hashing function designed to be slow and resistant to bruteforce attacks.
Technical Analysis: Provides strong security for password storage.
Example Test Case:
Input Data: "password"
Bcrypt Hash Output:
$2a$12$...
26. Bcrypt Compare
Description: Compares a password with a Bcrypt hash to verify correctness.
Example Test Case:
Input Password: "password", Bcrypt Hash:
$2a$12$...
Comparison Result: Valid/Invalid
27. Bcrypt Parse
Description: Parses a Bcrypt hash to extract its components, such as cost factor and salt.
Example Test Case:
Input Hash:
$2a$12$...
Parsed Output: Cost factor, salt, hashed password
28. Argon2
Description: Argon2 is a memoryhard password hashing function designed to be resistant to GPU cracking attacks.
Technical Analysis: Provides robust security features for password hashing.
Example Test Case:
Input Data: "password", Salt: "salt"
Argon2 Hash Output:
$argon2i$v=19$m=65536,t=2,p=1$...
29. Argon2 Compare
Description: Compares a password with an Argon2 hash to verify correctness.
Example Test Case:
Input Password: "password", Argon2 Hash:
$argon2i$v=19$m=65536,t=2,p=1$...
Comparison Result: Valid/Invalid
30. Scrypt
Description: Scrypt is a passwordbased key derivation function designed to be computationally intensive and memoryhard.
Technical Analysis: Provides strong protection against hardware bruteforce attacks.
Example Test Case:
Input Data: "password", Salt: "salt"
Scrypt Hash Output: Binary data derived from Scrypt function.
31. NT Hash
Description: NT Hash is a hashing algorithm used by Windows NTbased systems for password storage.
Technical Analysis: Hashes passwords in a caseinsensitive manner.
Example Test Case:
Input Data: "password"
NT Hash Output:
8846d186cafcf82f4f8d4d3d7f4b1b9b
32. LM Hash
Description: LM Hash is an older hashing algorithm used by Windows for password storage.
Technical Analysis: Known for its weak security and vulnerabilities.
Example Test Case:
Input Data: "password"
LM Hash Output:
8dce1b1e060dc2b0a0b7c034a14c5ef1
33. MurmurHash3
Description: MurmurHash3 is a noncryptographic hash function known for its speed and good distribution.
Technical Analysis: Used for hashbased data structures like hash tables.
Example Test Case:
Input Data: "hello"
MurmurHash3 Output:
5d41402abc4b2a76b9719d911017c592
34. Fletcher8 Checksum
Description: Fletcher8 is a checksum algorithm that provides error detection with 8bit checksum.
Technical Analysis: Simple and quick, used in errorchecking scenarios.
Example Test Case:
Input Data: "hello"
Fletcher8 Checksum Output:
0x6c
35. Fletcher16 Checksum
Description: Fletcher16 provides error detection with a 16bit checksum.
Technical Analysis: Offers better error detection than Fletcher8.
Example Test Case:
Input Data: "hello"
Fletcher16 Checksum Output:
0x14a1
36. Fletcher32 Checksum
Description: Fletcher32 provides a 32bit checksum for error detection.
Technical Analysis: More robust than Fletcher16 and suitable for larger data.
Example Test Case:
Input Data: "hello"
Fletcher32 Checksum Output:
0x7c4d
37. Fletcher64 Checksum
Description: Fletcher64 provides a 64bit checksum for enhanced error detection.
Technical Analysis: Suitable for very large data sets.
Example Test Case:
Input Data: "hello"
Fletcher64 Checksum Output:
0x3c11a
38. Adler32 Checksum
Description: Adler32 is a checksum algorithm that combines two 16bit sums.
Technical Analysis: Fast but less reliable than more advanced checksums.
Example Test Case:
Input Data: "hello"
Adler32 Checksum Output:
0x08e6
39. Luhn Checksum
Description: Luhn algorithm is used for validating various identification numbers.
Technical Analysis: Provides a simple method for error detection in identification numbers.
Example Test Case:
Input Data: "1234567812345670"
Luhn Checksum Output: Valid/Invalid
40. CRC8 Checksum
Description: CRC8 is a cyclic redundancy check with an 8bit checksum.
Technical Analysis: Used for errorchecking in communication protocols.
Example Test Case:
Input Data: "hello"
CRC8 Checksum Output:
0x64
41. CRC16 Checksum
Description: CRC16 is a cyclic redundancy check with a 16bit checksum.
Technical Analysis: Provides better error detection than CRC8.
Example Test Case:
Input Data: "hello"
CRC16 Checksum Output:
0x1c2b
42. CRC32 Checksum
Description: CRC32 is a widely used checksum algorithm providing a 32bit error detection code.
Technical Analysis: Commonly used in network protocols and file storage.
Example Test Case:
Input Data: "hello"
CRC32 Checksum Output:
0x3610a686
43. TCP/IP Checksum
Description: TCP/IP checksum is used to verify data integrity in TCP/IP packets.
Technical Analysis: Ensures data integrity during transmission over networks.
Example Test Case:
Input Data: Network packet data
TCP/IP Checksum Output: Calculated checksum value
Technical Analysis of Cryptographic Operations
Below is a detailed overview of various cryptographic operations with their technical analysis and example test cases.
1. Public Key
Description: A public key is part of a publicprivate key pair used in asymmetric encryption. It is used to encrypt data or verify signatures.
Technical Analysis: The public key can be distributed openly, while the private key is kept secret.
Example Test Case:
Input Data: Public Key (PEM format)
Operation: Verify the format and compatibility with encryption algorithms.
Output: Valid public key for use in encryption or signature verification.
2. Parse X.509 Certificate
Description: X.509 certificates are digital certificates that use the X.509 standard to provide information about the certificate holder and issuer.
Technical Analysis: Parsing involves extracting information like issuer, subject, validity period, and public key from the certificate.
Example Test Case:
Input Data: X.509 Certificate (PEM format)
Operation: Extract certificate details.
Output: Certificate details such as issuer, subject, and validity dates.
3. Parse ASN.1 Hex String
Description: ASN.1 (Abstract Syntax Notation One) is a standard interface description language for defining data structures. Hex strings can represent ASN.1 encoded data.
Technical Analysis: Parsing involves decoding ASN.1 encoded data from its hexadecimal representation.
Example Test Case:
Input Data: ASN.1 Hex String
Operation: Decode and interpret the hex string.
Output: Decoded ASN.1 data structure.
4. PEM to Hex
Description: Converts PEM (Privacy Enhanced Mail) encoded data into its hexadecimal representation.
Technical Analysis: PEM is a base64 encoded format with delimiters. Hex conversion involves decoding from base64 and then converting to hexadecimal.
Example Test Case:
Input Data: PEM Encoded Certificate
Operation: Decode PEM and convert to hex.
Output: Hexadecimal string of the certificate.
5. Hex to PEM
Description: Converts hexadecimal data into PEM (Privacy Enhanced Mail) format.
Technical Analysis: Hex to PEM conversion involves converting hex data to binary and then encoding it to base64 with PEM delimiters.
Example Test Case:
Input Data: Hexadecimal Data
Operation: Convert hex to PEM format.
Output: PEM encoded certificate.
6. Hex to Object Identifier
Description: Converts a hexadecimal representation to an Object Identifier (OID), a standard used to identify objects in cryptographic protocols.
Technical Analysis: Hex data is interpreted as an OID, which is usually represented in a dotteddecimal format.
Example Test Case:
Input Data: Hexadecimal OID
Operation: Convert hex to OID.
Output: Object Identifier in dotteddecimal format.
7. Object Identifier to Hex
Description: Converts an Object Identifier (OID) to its hexadecimal representation.
Technical Analysis: OIDs are typically represented in a dotteddecimal format, which is converted to a hexadecimal string.
Example Test Case:
Input Data: Object Identifier (e.g.,
1.2.840.113549
)Operation: Convert OID to hex.
Output: Hexadecimal representation of the OID.
8. PEM to JWK
Description: Converts a PEM encoded key to a JSON Web Key (JWK) format.
Technical Analysis: PEM is base64 encoded with headers/footers, while JWK is a JSON representation of the key.
Example Test Case:
Input Data: PEM Encoded Public Key
Operation: Convert PEM to JWK.
Output: JSON Web Key representation.
9. JWK to PEM
Description: Converts a JSON Web Key (JWK) to PEM format.
Technical Analysis: JWK is a JSON format, and PEM is a base64 encoded format with headers.
Example Test Case:
Input Data: JSON Web Key
Operation: Convert JWK to PEM.
Output: PEM encoded key.
10. Generate PGP Key Pair
Description: Generates a PGP (Pretty Good Privacy) key pair for encryption and signing.
Technical Analysis: PGP key pairs consist of a public key and a private key used for encryption and decryption or signing and verification.
Example Test Case:
Operation: Generate key pair with specified parameters.
Output: PGP public and private keys.
11. PGP Encrypt
Description: Encrypts data using a PGP public key.
Technical Analysis: PGP encryption involves using the recipient's public key to encrypt data.
Example Test Case:
Input Data: Plaintext message, PGP Public Key
Operation: Encrypt message using the public key.
Output: Encrypted data.
12. PGP Decrypt
Description: Decrypts data using a PGP private key.
Technical Analysis: PGP decryption involves using the private key to decrypt data encrypted with the corresponding public key.
Example Test Case:
Input Data: Encrypted message, PGP Private Key
Operation: Decrypt message using the private key.
Output: Decrypted message.
13. PGP Verify
Description: Verifies a PGP signature on a message.
Technical Analysis: PGP verification involves checking if a signature matches the message and the public key.
Example Test Case:
Input Data: Signed message, PGP Public Key
Operation: Verify signature using the public key.
Output: Verification result (valid/invalid).
14. PGP Encrypt and Sign
Description: Encrypts and signs a message using PGP.
Technical Analysis: Combines encryption and signing to ensure confidentiality and authenticity.
Example Test Case:
Input Data: Plaintext message, PGP Public Key, PGP Private Key
Operation: Encrypt and sign the message.
Output: Encrypted and signed message.
15. PGP Decrypt and Verify
Description: Decrypts and verifies a PGP message.
Technical Analysis: Decrypts the message with the private key and verifies the signature.
Example Test Case:
Input Data: Encrypted and signed message, PGP Private Key, PGP Public Key
Operation: Decrypt and verify the message.
Output: Decrypted message and verification result.
16. Generate RSA Key Pair
Description: Generates an RSA key pair consisting of a public key and a private key.
Technical Analysis: RSA keys are used for secure data encryption and digital signatures.
Example Test Case:
Operation: Generate RSA key pair with specified key size.
Output: RSA public and private keys.
17. RSA Sign
Description: Signs data using an RSA private key.
Technical Analysis: RSA signing involves creating a digital signature for data using the private key.
Example Test Case:
Input Data: Data to be signed, RSA Private Key
Operation: Generate signature using the private key.
Output: Digital signature.
18. RSA Verify
Description: Verifies an RSA signature using the corresponding public key.
Technical Analysis: RSA verification involves checking if the signature matches the data and the public key.
Example Test Case:
Input Data: Data, RSA Signature, RSA Public Key
Operation: Verify signature using the public key.
Output: Verification result (valid/invalid).
19. RSA Encrypt
Description: Encrypts data using an RSA public key.
Technical Analysis: RSA encryption involves using the public key to encrypt data.
Example Test Case:
Input Data: Plaintext message, RSA Public Key
Operation: Encrypt message using the public key.
Output: Encrypted data.
20. RSA Decrypt
Description: Decrypts data using an RSA private key.
Technical Analysis: RSA decryption involves using the private key to decrypt data encrypted with the corresponding public key.
Example Test Case:
Input Data: Encrypted message, RSA Private Key
Operation: Decrypt message using the private key.
Output: Decrypted message.
21. Generate ECDSA Key Pair
Description: Generates an ECDSA (Elliptic Curve Digital Signature Algorithm) key pair.
Technical Analysis: ECDSA provides a secure and efficient method for digital signatures using elliptic curve cryptography.
Example Test Case:
Operation: Generate ECDSA key pair with specified curve.
Output: ECDSA public and private keys.
22. ECDSA Signature Conversion
Description: Converts an ECDSA signature between different formats.
Technical Analysis: ECDSA signatures can be represented in various formats, such as DER or PEM.
Example Test Case:
Input Data: ECDSA Signature in DER format
Operation: Convert to PEM format.
Output: ECDSA signature in PEM format.
23. ECDSA Sign
Description: Signs data using an ECDSA private key.
Technical Analysis: ECDSA signing involves generating a digital signature for data using the private key.
Example Test Case:
Input Data: Data to be signed, ECDSA Private Key
Operation: Generate signature using the private key.
Output: Digital signature.
24. ECDSA Verify
Description: Verifies an ECDSA signature using the corresponding public key.
Technical Analysis: ECDSA verification involves checking if the signature matches the data and the public key.
Example Test Case:
Input Data: Data, ECDSA Signature, ECDSA Public Key
Operation: Verify signature using the public key.
Output: Verification result (valid/invalid).
25. Parse SSH Host Key
Description: Parses an SSH host key to extract relevant information.
Technical Analysis: SSH host keys are used for authenticating SSH servers. Parsing involves extracting key type and key data.
Example Test Case:
Input Data: SSH Host Key (PEM format)
Operation: Extract key type and key data.
Output: Parsed SSH host key information.
26. Parse CSR
Description: Parses a Certificate Signing Request (CSR) to extract details such as the public key and subject information.
Technical Analysis: CSRs are used to request certificates from a certificate authority. Parsing involves extracting and interpreting the request data.
Example Test Case:
Input Data: CSR (PEM format)
Operation: Extract public key, subject, and other details.
Output: Parsed CSR details.
27. Public Key from Certificate
Description: Extracts the public key from an X.509 certificate.
Technical Analysis: The public key is embedded in the certificate and can be extracted for use in encryption or signature verification.
Example Test Case:
Input Data: X.509 Certificate (PEM format)
Operation: Extract public key from the certificate.
Output: Public key.
28. Public Key from Private Key
Description: Derives the public key from a private key.
Technical Analysis: The public key can be derived from the private key using cryptographic algorithms.
Example Test Case:
Input Data: Private Key (PEM format)
Operation: Derive the corresponding public key.
Output: Public key.
Data Format Conversion Algorithms
Here’s a detailed breakdown of various data format conversions, including technical analysis and example test cases for each item.
1. To Hexdump
Description: Converts binary data into a hex dump format where each byte is represented by its hexadecimal value.
Technical Analysis: This format is useful for debugging and visualizing binary data. Each byte is converted into a twodigit hexadecimal representation, often accompanied by an ASCII representation of the data.
Example Test Case:
Input Data: Binary data
b'\x01\x02\x03'
Operation: Convert to hex dump.
Output:
00000000 01 02 03
2. From Hexdump
Description: Converts a hex dump back into binary data.
Technical Analysis: This involves parsing the hexadecimal values and converting them back into their original binary format.
Example Test Case:
Input Data: Hex dump
01 02 03
Operation: Convert to binary.
Output: Binary data
b'\x01\x02\x03'
3. To Hex
Description: Converts binary data into a hexadecimal string.
Technical Analysis: Each byte of binary data is converted to its twodigit hexadecimal representation.
Example Test Case:
Input Data: Binary data
b'\x10\x20\x30'
Operation: Convert to hex.
Output:
102030
4. From Hex
Description: Converts a hexadecimal string back into binary data.
Technical Analysis: The hexadecimal string is parsed into bytes, reconstructing the original binary data.
Example Test Case:
Input Data: Hex string
102030
Operation: Convert to binary.
Output: Binary data
b'\x10\x20\x30'
5. To Charcode
Description: Converts text into a sequence of character codes (e.g., ASCII or Unicode).
Technical Analysis: Each character in the text is translated into its corresponding numeric code.
Example Test Case:
Input Data: Text
ABC
Operation: Convert to charcodes.
Output:
[65, 66, 67]
(ASCII codes forA
,B
,C
)
6. From Charcode
Description: Converts a sequence of character codes back into text.
Technical Analysis: Numeric codes are converted into their corresponding characters to reconstruct the original text.
Example Test Case:
Input Data: Character codes
[65, 66, 67]
Operation: Convert to text.
Output:
ABC
7. To Decimal
Description: Converts binary or other numeric representations into decimal numbers.
Technical Analysis: This involves interpreting the binary or other number format as a decimal number.
Example Test Case:
Input Data: Binary
1010
Operation: Convert to decimal.
Output:
10
8. From Decimal
Description: Converts a decimal number into its binary representation.
Technical Analysis: Decimal numbers are converted into binary or other numeric formats.
Example Test Case:
Input Data: Decimal
10
Operation: Convert to binary.
Output: Binary
1010
9. To Float
Description: Converts numeric values into floatingpoint numbers.
Technical Analysis: Numeric data is interpreted as floatingpoint values, useful for precision in calculations.
Example Test Case:
Input Data: Decimal
3.14
Operation: Convert to float.
Output:
3.14
10. From Float
Description: Converts floatingpoint numbers back into numeric representations.
Technical Analysis: Floatingpoint numbers are parsed to their numeric equivalents.
Example Test Case:
Input Data: Float
3.14
Operation: Convert to decimal.
Output:
3.14
11. To Binary
Description: Converts numeric data or text into its binary representation.
Technical Analysis: Converts data into a sequence of 0s and 1s.
Example Test Case:
Input Data: Decimal
10
Operation: Convert to binary.
Output: Binary
1010
12. From Binary
Description: Converts binary data back into numeric values or text.
Technical Analysis: Converts binary sequences into their original format.
Example Test Case:
Input Data: Binary
1010
Operation: Convert to decimal.
Output: Decimal
10
13. To Octal
Description: Converts numeric data into octal representation.
Technical Analysis: Octal numbers use base8 numeral system, representing binary data more compactly.
Example Test Case:
Input Data: Decimal
64
Operation: Convert to octal.
Output:
100
14. From Octal
Description: Converts octal numbers back into decimal or binary formats.
Technical Analysis: Octal numbers are interpreted as decimal or binary.
Example Test Case:
Input Data: Octal
100
Operation: Convert to decimal.
Output: Decimal
64
15. To Base32
Description: Converts binary data into a base32 encoded string.
Technical Analysis: Base32 encoding represents binary data using 32 different symbols.
Example Test Case:
Input Data: Binary data
b'hello'
Operation: Convert to Base32.
Output:
NBSWY3DPFQQFO33SNRSCC
16. From Base32
Description: Converts a base32 encoded string back into binary data.
Technical Analysis: Base32 decoding retrieves binary data from its encoded form.
Example Test Case:
Input Data: Base32
NBSWY3DPFQQFO33SNRSCC
Operation: Convert to binary data.
Output: Binary data
b'hello'
17. To Base45
Description: Converts binary data into base45 encoded format.
Technical Analysis: Base45 uses a specific set of 45 symbols to represent binary data.
Example Test Case:
Input Data: Binary data
b'hello'
Operation: Convert to Base45.
Output:
4DEa+
18. From Base45
Description: Converts a base45 encoded string back into binary data.
Technical Analysis: Base45 decoding retrieves the original binary data from its encoded format.
Example Test Case:
Input Data: Base45
4DEa+
Operation: Convert to binary data.
Output: Binary data
b'hello'
19. To Base58
Description: Converts binary data into base58 encoded format.
Technical Analysis: Base58 encoding is used in Bitcoin and other applications to avoid similarlooking characters.
Example Test Case:
Input Data: Binary data
b'hello'
Operation: Convert to Base58.
Output:
J1U7Wq
20. From Base58
Description: Converts a base58 encoded string back into binary data.
Technical Analysis: Base58 decoding retrieves the binary data from its encoded form.
Example Test Case:
Input Data: Base58
J1U7Wq
Operation: Convert to binary data.
Output: Binary data
b'hello'
21. To Base62
Description: Converts binary data into base62 encoded format.
Technical Analysis: Base62 encoding uses 62 characters (09, AZ, az) for encoding.
Example Test Case:
Input Data: Binary data
b'hello'
Operation: Convert to Base62.
Output:
A1B2C3
22. From Base62
Description: Converts a base62 encoded string back into binary data.
Technical Analysis: Base62 decoding retrieves the original binary data from its encoded form.
Example Test Case:
Input Data: Base62
A1B2C3
Operation: Convert to binary data.
Output: Binary data
b'hello'
23. To Base64
Description: Converts binary data into base64 encoded format.
Technical Analysis: Base64 encoding represents binary data using 64 different characters, often used for data transmission.
Example Test Case:
Input Data: Binary data
b'hello'
Operation: Convert to Base64.
Output:
aGVsbG8=
24. From Base64
Description: Converts a base64 encoded string back into binary data.
Technical Analysis: Base64 decoding retrieves the binary data from its encoded format.
Example Test Case:
Input Data: Base64
aGVsbG8=
Operation: Convert to binary data.
Output: Binary data
b'hello'
25. Show Base64 Offsets
Description: Displays the offsets of Base64 encoded data, often for debugging or data verification.
Technical Analysis: Displays the positions of Base64 encoded characters within the data for detailed examination.
Example Test Case:
Input Data: Base64
aGVsbG8=
Operation: Display offsets.
Output: Offset positions in the Base64 string.
26. To Base92
Description: Converts binary data into base92 encoded format.
Technical Analysis: Base92 encoding uses 92 characters, providing a compact representation for binary data.
Example Test Case:
Input Data: Binary data
b'hello'
Operation: Convert to Base92.
Output:
0A1B2C
27. From Base92
Description: Converts a base92 encoded string back into binary data.
Technical Analysis: Base92 decoding retrieves the original binary data from its encoded format.
Example Test Case:
Input Data: Base92
0A1B2C
Operation: Convert to binary data.
Output: Binary data
b'hello'
28. To Base85
Description: Converts binary data into base85 encoded format.
Technical Analysis: Base85 encoding uses 85 characters for a more compact binary representation.
Example Test Case:
Input Data: Binary data
b'hello'
Operation: Convert to Base85.
Output:
9jqo^@
29. From Base85
Description: Converts a base85 encoded string back into binary data.
Technical Analysis: Base85 decoding retrieves the binary data from its encoded form.
Example Test Case:
Input Data: Base85
9jqo^@
Operation: Convert to binary data.
Output: Binary data
b'hello'
30. To Base
Description: Converts binary data into a custom base encoding format.
Technical Analysis: Base encoding transforms binary data into a specified base representation, like base16 (hex) or base64.
Example Test Case:
Input Data: Binary data
b'hello'
Operation: Convert to custom base (e.g., base16).
Output: Hex
68656c6c6f
31. From Base
Description: Converts data from a custom base format back to binary.
Technical Analysis: Custom base decoding retrieves the binary data from its encoded form.
Example Test Case:
Input Data: Base16
68656c6c6f
Operation: Convert to binary data.
Output: Binary data
b'hello'
32. To BCD
Description: Converts binary data into BinaryCoded Decimal (BCD) format.
Technical Analysis: BCD encodes each decimal digit into its binary equivalent.
Example Test Case:
Input Data: Decimal
123
Operation: Convert to BCD.
Output:
0001 0010 0011
33. From BCD
Description: Converts BCD encoded data back into decimal format.
Technical Analysis: BCD decoding retrieves decimal values from their binaryencoded form.
Example Test Case:
Input Data: BCD
0001 0010 0011
Operation: Convert to decimal.
Output: Decimal
123
34. To HTML Entity
Description: Converts characters into their HTML entity representations.
Technical Analysis: HTML entities are used to represent characters that are not easily typable or to avoid conflicts with HTML syntax.
Example Test Case:
Input Data: Text
& < >
Operation: Convert to HTML entities.
Output:
& < >
35. From HTML Entity
Description: Converts HTML entities back into their corresponding characters.
Technical Analysis: HTML entities are decoded to their original characters for display or processing.
Example Test Case:
Input Data: HTML entities
& < >
Operation: Convert to text.
Output:
& < >
36. URL Encode
Description: Encodes text for safe transmission in URLs by escaping characters.
Technical Analysis: URL encoding replaces unsafe characters with percentencoded values.
Example Test Case:
Input Data: Text
hello world
Operation: URL encode.
Output:
hello%20world
37. URL Decode
Description: Decodes URLencoded text back to its original form.
Technical Analysis: URL decoding reverses the encoding process to retrieve the original text.
Example Test Case:
Input Data: URLencoded text
hello%20world
Operation: URL decode.
Output:
hello world
38. Escape Unicode Characters
Description: Escapes Unicode characters in a text to ensure proper representation in different environments.
Technical Analysis: Unicode characters are replaced with their escape sequences.
Example Test Case:
Input Data: Text
hello 😊
Operation: Escape Unicode.
Output:
hello \u263A
39. Unescape Unicode Characters
Description: Converts Unicode escape sequences back to their original characters.
Technical Analysis: Unicode escape sequences are decoded into their actual characters.
Example Test Case:
Input Data: Text with Unicode escapes
hello \u263A
Operation: Unescape Unicode.
Output:
hello 😊
40. Normalize Unicode
Description: Converts Unicode text to a normalized form to ensure consistency.
Technical Analysis: Unicode normalization standardizes text to a specific format to handle equivalences.
Example Test Case:
Input Data: Unicode text
é
(U+00E9) andé
(U+0065 U+0301)Operation: Normalize Unicode.
Output:
é
(NFC form)
41. To Quoted Printable
Description: Encodes text into a quotedprintable format to ensure safe transmission over media.
Technical Analysis: Quotedprintable encoding represents nonprintable characters with printable ASCII characters.
Example Test Case:
Input Data: Text
hello=world
Operation: Convert to quotedprintable.
Output:
hello=3Dworld
42. From Quoted Printable
Description: Decodes quotedprintable text back to its original form.
Technical Analysis: Quotedprintable decoding reverses the encoding process.
Example Test Case:
Input Data: Quotedprintable text
hello=3Dworld
Operation: Convert to text.
Output:
hello=world
43. To Punycode
Description: Converts Unicode domain names to Punycode for use in DNS.
Technical Analysis: Punycode encoding transforms Unicode domain names into ASCIIcompatible encoding.
Example Test Case:
Input Data: Unicode domain
münich.com
Operation: Convert to Punycode.
Output:
xn
mnichkva.com
44. From Punycode
Description: Converts Punycode encoded domain names back to Unicode.
Technical Analysis: Punycode decoding retrieves the original Unicode domain name.
Example Test Case:
Input Data: Punycode
xn
mnichkva.com
Operation: Convert to Unicode.
Output:
münich.com
45. AMF Encode
Description: Encodes data into Action Message Format (AMF) for serialization in Flash applications.
Technical Analysis: AMF encoding converts data structures into a binary format for use with Adobe Flash.
Example Test Case:
Input Data: Data
{ "name": "John", "age": 30 }
Operation: Encode to AMF.
Output: AMFencoded binary data.
46. AMF Decode
Description: Decodes AMFencoded data back into its original format.
Technical Analysis: AMF decoding converts binary data back into usable data structures.
Example Test Case:
Input Data: AMFencoded binary data.
Operation: Decode to original data.
Output: Data
{ "name": "John", "age": 30 }
47. To Hex Content
Description: Converts binary content into a hexadecimal representation.
Technical Analysis: Each byte of binary data is converted into its twodigit hexadecimal representation.
Example Test Case:
Input Data: Binary content
b'\xAB\xCD'
Operation: Convert to hex content.
Output:
ABCD
48. From Hex Content
Description: Converts a hexadecimal string back into binary content.
Technical Analysis: Hexadecimal strings are parsed and converted into their binary equivalent.
Example Test Case:
Input Data: Hex content
ABCD
Operation: Convert to binary content.
Output: Binary content
b'\xAB\xCD'
49. PEM to Hex
Description: Converts a PEM encoded string (typically for certificates) into its hexadecimal representation.
Technical Analysis: PEM data is base64 encoded and includes headers and footers, which are stripped out before conversion.
Example Test Case:
Input Data: PEM certificate
BEGIN CERTIFICATE ... END CERTIFICATE
Operation: Convert to hex.
Output: Hexadecimal string of the PEMencoded data.
50. Hex to PEM
Description: Converts hexadecimal data into PEM format.
Technical Analysis: Hexadecimal data is converted into base64 and formatted with PEM headers and footers.
Example Test Case:
Input Data: Hexadecimal string.
Operation: Convert to PEM.
Output: PEM formatted certificate.
51. Parse ASN.1 Hex String
Description: Parses a hexadecimal string representing ASN.1 (Abstract Syntax Notation One) encoded data.
Technical Analysis: ASN.1 is used for encoding data structures, and parsing involves interpreting the encoded information.
Example Test Case:
Input Data: ASN.1 hex string.
Operation: Parse ASN.1.
Output: Interpreted ASN.1 data structure.
52. Change IP Format
Description: Converts between different IP address formats (e.g., IPv4 and IPv6).
Technical Analysis: Involves parsing and converting IP address formats to ensure compatibility and proper representation.
Example Test Case:
Input Data: IPv4 address
192.168.1.1
Operation: Convert to IPv6.
Output: IPv6 format address.
53. Encode Text
Description: Converts text into a specific encoding format.
Technical Analysis: Encoding transforms text into different formats (e.g., UTF8, ASCII).
Example Test Case:
Input Data: Text
hello
Operation: Encode to UTF8.
Output: UTF8 encoded byte sequence.
54. Decode Text
Description: Converts encoded text back into its original form.
Technical Analysis: Decoding reverses the encoding process to retrieve the original text.
Example Test Case:
Input Data: UTF8 encoded byte sequence.
Operation: Decode to text.
Output: Original text
hello
55. Text Encoding Brute Force
Description: Attempts to identify text encoding by testing various encoding schemes.
Technical Analysis: Brute force encoding involves trying multiple encoding formats to determine the correct one.
Example Test Case:
Input Data: Unknown encoded text.
Operation: Brute force test encodings.
Output: Identified encoding format.
56. Swap Endianness
Description: Converts between bigendian and littleendian representations.
Technical Analysis: Endianness affects the byte order of multibyte data types, and swapping adjusts the byte order accordingly.
Example Test Case:
Input Data: Littleendian
0x12345678
Operation: Swap endianness.
Output: Bigendian
0x78563412
57. To MessagePack
Description: Converts data into MessagePack format for efficient serialization.
Technical Analysis: MessagePack is a binary format that serializes data structures efficiently.
Example Test Case:
Input Data: Data
{ "name": "John", "age": 30 }
Operation: Convert to MessagePack.
Output: MessagePack binary data.
58. From MessagePack
Description: Converts MessagePack data back into its original format.
Technical Analysis: Decoding MessagePack involves interpreting the binary data into data structures.
Example Test Case:
Input Data: MessagePack binary data.
Operation: Convert to original data.
Output: Data
{ "name": "John", "age": 30 }
59. To Braille
Description: Converts text into Braille representation.
Technical Analysis: Braille encoding represents text as tactile symbols for visually impaired users.
Example Test Case:
Input Data: Text
hello
Operation: Convert to Braille.
Output: Braille representation of
hello
.
60. From Braille
Description: Converts Braille representation back into text.
Technical Analysis: Braille decoding retrieves the original text from its Braille representation.
Example Test Case:
Input Data: Braille representation.
Operation: Convert to text.
Output: Original text
hello
61. Parse TLV
Description: Parses TypeLengthValue (TLV) encoded data.
Technical Analysis: TLV encoding formats data into a structured format with type, length, and value fields.
Example Test Case:
Input Data: TLV encoded data.
Operation: Parse TLV.
Output: Extracted type, length, and value fields.
62. CSV to JSON
Description: Converts CSV data into JSON format.
Technical Analysis: CSV (CommaSeparated Values) data is parsed and transformed into JSON (JavaScript Object Notation) structures.
Example Test Case:
Input Data: CSV
name,age\nJohn,30
Operation: Convert to JSON.
Output: JSON
{ "name": "John", "age": 30 }
63. JSON to CSV
Description: Converts JSON data into CSV format.
Technical Analysis: JSON structures are converted into CSV rows and columns.
Example Test Case:
Input Data: JSON
{ "name": "John", "age": 30 }
Operation: Convert to CSV.
Output: CSV
name,age\nJohn,30
64. Avro to JSON
Description: Converts Avro data format to JSON.
Technical Analysis: Avro is a binary format used for data serialization, and JSON is a textbased format. Conversion involves parsing Avro binary and formatting it into JSON.
Example Test Case:
Input Data: Avro binary data.
Operation: Convert to JSON.
Output: JSON representation of Avro data.
65. CBOR Encode
Description: Encodes data into Concise Binary Object Representation (CBOR) format.
Technical Analysis: CBOR is a binary format similar to JSON but more compact.
Example Test Case:
Input Data: Data
{ "name": "John", "age": 30 }
Operation: Convert to CBOR.
Output: CBOR binary data.
66. CBOR Decode
Description: Decodes CBOR formatted data back into its original format.
Technical Analysis: Decoding CBOR involves interpreting the binary data into data structures.
Example Test Case:
Input Data: CBOR binary data.
Operation: Convert to original data.
Output: Data
{ "name": "John", "age": 30 }
67. Caret/Mdecode
Description: Decodes Caret or Mdecoded data, used for special encodings or protocols.
Technical Analysis: This involves parsing and interpreting Caret or Mdecoded data to retrieve the original content.
Example Test Case:
Input Data: Caret/Mencoded data.
Operation: Decode Caret/M.
Output: Original data.
68. Rison Encode
Description: Encodes data into Rison format, a compact JSONlike format.
Technical Analysis: Rison encoding provides a more compact representation of JSON data.
Example Test Case:
Input Data: Data
{ "name": "John", "age": 30 }
Operation: Convert to Rison.
Output: Rison encoded string.
69. Rison Decode
Description: Decodes Rison formatted data back into JSON format.
Technical Analysis: Rison decoding involves parsing the compact Rison format into standard JSON.
Example Test Case:
Input Data: Rison encoded string.
Operation: Convert to JSON.
Output: JSON
{ "name": "John", "age": 30 }