Communities

Writing
Writing
Codidact Meta
Codidact Meta
The Great Outdoors
The Great Outdoors
Photography & Video
Photography & Video
Scientific Speculation
Scientific Speculation
Cooking
Cooking
Electrical Engineering
Electrical Engineering
Judaism
Judaism
Languages & Linguistics
Languages & Linguistics
Software Development
Software Development
Mathematics
Mathematics
Christianity
Christianity
Code Golf
Code Golf
Music
Music
Physics
Physics
Linux Systems
Linux Systems
Power Users
Power Users
Tabletop RPGs
Tabletop RPGs
Community Proposals
Community Proposals
tag:snake search within a tag
answers:0 unanswered questions
user:xxxx search by author id
score:0.5 posts with 0.5+ score
"snake oil" exact phrase
votes:4 posts with 4+ votes
created:<1w created < 1 week ago
post_type:xxxx type of post
Search help
Notifications
Mark all as read See all your notifications »
Users Search
Help Dashboard Sign In Sign Up
Challenges Q&A Sandbox Meta
Sandbox
Posts Tags Edits
Create Draft

Post History

33%
+0 −2
Sandbox 💥 CHALLENGE: Find a Collision in Leviathan v3.1 (Deterministic)

The Context: I have officially deprecated SHA-2 and SHA-3. This decision stems from a critical security breach I witnessed: a virus that infected my system using forged digital signatures that wer...

posted 8mo ago by KaoruAK‭  ·  edited 8mo ago by KaoruAK‭

Article code-challenge
#5: Post edited by user avatar KaoruAK‭ · 2026-01-16T02:28:09Z (8 months ago)
  • **The Context:**
  • I have officially deprecated SHA-2 and SHA-3. This decision stems from a critical security breach I witnessed: a virus that infected my system using forged digital signatures that were somehow validated as authentic by current standards. This proved that the 'trust' in existing hashing algorithms is compromised. Consequently, I have engineered Leviathan v3.1 Turbo to replace them with a system that doesn't just verify, but defends.
  • **The Logic:**
  • This algorithm uses a **Fractal Carry** system and a massive **10,000-digit Prime Constant** to ensure that even the slightest bit-flip in the input causes a catastrophic avalanche in the output.
  • **The Task:**
  • Simple. **Find a Collision.**
  • Find two distinct inputs (strings or byte arrays) and such that:
  • $$Leviathan(M_1) == Leviathan(M_2)$$
  • Where $M_1 \neq M_2$
  • **The Code:**
  • The algorithm is fully **DETERMINISTIC**. No random salts. Pure math.
  • **[Get the Source Code Here (OSF)](https://osf.io/8xb9h/files/aj92b)**
  • **Why you will fail:**
  • * The "Displaced Mutation Buffer" prevents linear collisions.
  • * The output space is **1024 characters**. The Pigeonhole Principle is on my side, not yours.
  • * The internal state evolves fractally, meaning depends non-linearly on .
  • Or maybe they’ll manage to break the algorithm!
  • **Rules**
  • There will be a maximum of 3 winners. The first 3 to succeed will win, and they must present the algorithm or explain how their code works.
  • **Prize:**
  • The glory of breaking the first post-NIST hash algorithm.
  • **"Good luck. You'll need more than a supercomputer; you'll need a new dimension."**
  • **The Context:**
  • I have officially deprecated SHA-2 and SHA-3. This decision stems from a critical security breach I witnessed: a virus that infected my system using forged digital signatures that were somehow validated as authentic by current standards. This proved that the 'trust' in existing hashing algorithms is compromised. Consequently, I have engineered Leviathan v3.1 Turbo to replace them with a system that doesn't just verify, but defends.
  • **The Logic:**
  • This algorithm uses a **Fractal Carry** system and a massive **10,000-digit Prime Constant** to ensure that even the slightest bit-flip in the input causes a catastrophic avalanche in the output.
  • **The Task:**
  • Simple. **Find a Collision.**
  • Find two distinct inputs (strings or byte arrays) and such that:
  • $$Leviathan(M_1) == Leviathan(M_2)$$
  • Where $M_1 \neq M_2$
  • **The Code:**
  • The algorithm is fully **DETERMINISTIC**. No random salts. Pure math.
  • **[Get the Source Code Here (OSF)](https://osf.io/8xb9h/files/aj92b)**
  • **Why you will fail:**
  • * The "Displaced Mutation Buffer" prevents linear collisions.
  • * The output space is **1024 characters**. The Pigeonhole Principle is on my side, not yours.
  • * The internal state evolves fractally, meaning depends non-linearly on .
  • **Rules**
  • There will be a maximum of 3 winners. The first 3 to succeed will win, and they must present the algorithm or explain how their code works.
  • **Prize:**
  • The glory of breaking the first post-NIST hash algorithm.
  • **"Good luck. You'll need more than a supercomputer; you'll need a new dimension."**
#4: Post edited by user avatar KaoruAK‭ · 2026-01-16T02:27:49Z (8 months ago)
  • **The Context:**
  • I have officially deprecated SHA-2 and SHA-3. This decision stems from a critical security breach I witnessed: a virus that infected my system using forged digital signatures that were somehow validated as authentic by current standards. This proved that the 'trust' in existing hashing algorithms is compromised. Consequently, I have engineered Leviathan v3.1 Turbo to replace them with a system that doesn't just verify, but defends.
  • **The Logic:**
  • This algorithm uses a **Fractal Carry** system and a massive **10,000-digit Prime Constant** to ensure that even the slightest bit-flip in the input causes a catastrophic avalanche in the output.
  • **The Task:**
  • Simple. **Find a Collision.**
  • Find two distinct inputs (strings or byte arrays) and such that:
  • $$Leviathan(M_1) == Leviathan(M_2)$$
  • Where $M_1 \neq M_2$
  • **The Code:**
  • The algorithm is fully **DETERMINISTIC**. No random salts. Pure math.
  • **[Get the Source Code Here (OSF)](https://osf.io/8xb9h/files/aj92b)**
  • **Why you will fail:**
  • * The "Displaced Mutation Buffer" prevents linear collisions.
  • * The output space is **1024 characters**. The Pigeonhole Principle is on my side, not yours.
  • * The internal state evolves fractally, meaning depends non-linearly on .
  • **Rules**
  • There will be a maximum of 3 winners. The first 3 to succeed will win, and they must present the algorithm or explain how their code works.
  • **Prize:**
  • The glory of breaking the first post-NIST hash algorithm.
  • **"Good luck. You'll need more than a supercomputer; you'll need a new dimension."**
  • **The Context:**
  • I have officially deprecated SHA-2 and SHA-3. This decision stems from a critical security breach I witnessed: a virus that infected my system using forged digital signatures that were somehow validated as authentic by current standards. This proved that the 'trust' in existing hashing algorithms is compromised. Consequently, I have engineered Leviathan v3.1 Turbo to replace them with a system that doesn't just verify, but defends.
  • **The Logic:**
  • This algorithm uses a **Fractal Carry** system and a massive **10,000-digit Prime Constant** to ensure that even the slightest bit-flip in the input causes a catastrophic avalanche in the output.
  • **The Task:**
  • Simple. **Find a Collision.**
  • Find two distinct inputs (strings or byte arrays) and such that:
  • $$Leviathan(M_1) == Leviathan(M_2)$$
  • Where $M_1 \neq M_2$
  • **The Code:**
  • The algorithm is fully **DETERMINISTIC**. No random salts. Pure math.
  • **[Get the Source Code Here (OSF)](https://osf.io/8xb9h/files/aj92b)**
  • **Why you will fail:**
  • * The "Displaced Mutation Buffer" prevents linear collisions.
  • * The output space is **1024 characters**. The Pigeonhole Principle is on my side, not yours.
  • * The internal state evolves fractally, meaning depends non-linearly on .
  • Or maybe they’ll manage to break the algorithm!
  • **Rules**
  • There will be a maximum of 3 winners. The first 3 to succeed will win, and they must present the algorithm or explain how their code works.
  • **Prize:**
  • The glory of breaking the first post-NIST hash algorithm.
  • **"Good luck. You'll need more than a supercomputer; you'll need a new dimension."**
#3: Post edited by user avatar KaoruAK‭ · 2026-01-16T02:26:32Z (8 months ago)
  • **The Context:**
  • I have officially deprecated SHA-2 and SHA-3. This decision stems from a critical security breach I witnessed: a virus that infected my system using forged digital signatures that were somehow validated as authentic by current standards. This proved that the 'trust' in existing hashing algorithms is compromised. Consequently, I have engineered Leviathan v3.1 Turbo to replace them with a system that doesn't just verify, but defends.
  • **The Logic:**
  • This algorithm uses a **Fractal Carry** system and a massive **10,000-digit Prime Constant** to ensure that even the slightest bit-flip in the input causes a catastrophic avalanche in the output.
  • **The Task:**
  • Simple. **Find a Collision.**
  • Find two distinct inputs (strings or byte arrays) and such that:
  • $$Leviathan(M_1) == Leviathan(M_2)$$
  • Where $M_1 \neq M_2$
  • **The Code:**
  • The algorithm is fully **DETERMINISTIC**. No random salts. Pure math.
  • **[Get the Source Code Here (OSF)](https://osf.io/8xb9h/files/aj92b)**
  • **Why you will fail:**
  • * The "Displaced Mutation Buffer" prevents linear collisions.
  • * The output space is **1024 characters**. The Pigeonhole Principle is on my side, not yours.
  • * The internal state evolves fractally, meaning depends non-linearly on .
  • **Prize:**
  • The glory of breaking the first post-NIST hash algorithm.
  • **"Good luck. You'll need more than a supercomputer; you'll need a new dimension."**
  • **The Context:**
  • I have officially deprecated SHA-2 and SHA-3. This decision stems from a critical security breach I witnessed: a virus that infected my system using forged digital signatures that were somehow validated as authentic by current standards. This proved that the 'trust' in existing hashing algorithms is compromised. Consequently, I have engineered Leviathan v3.1 Turbo to replace them with a system that doesn't just verify, but defends.
  • **The Logic:**
  • This algorithm uses a **Fractal Carry** system and a massive **10,000-digit Prime Constant** to ensure that even the slightest bit-flip in the input causes a catastrophic avalanche in the output.
  • **The Task:**
  • Simple. **Find a Collision.**
  • Find two distinct inputs (strings or byte arrays) and such that:
  • $$Leviathan(M_1) == Leviathan(M_2)$$
  • Where $M_1 \neq M_2$
  • **The Code:**
  • The algorithm is fully **DETERMINISTIC**. No random salts. Pure math.
  • **[Get the Source Code Here (OSF)](https://osf.io/8xb9h/files/aj92b)**
  • **Why you will fail:**
  • * The "Displaced Mutation Buffer" prevents linear collisions.
  • * The output space is **1024 characters**. The Pigeonhole Principle is on my side, not yours.
  • * The internal state evolves fractally, meaning depends non-linearly on .
  • **Rules**
  • There will be a maximum of 3 winners. The first 3 to succeed will win, and they must present the algorithm or explain how their code works.
  • **Prize:**
  • The glory of breaking the first post-NIST hash algorithm.
  • **"Good luck. You'll need more than a supercomputer; you'll need a new dimension."**
#2: Post edited by user avatar KaoruAK‭ · 2026-01-16T02:25:06Z (8 months ago)
code-golf
code-challenge
#1: Initial revision by user avatar KaoruAK‭ · 2026-01-14T18:19:50Z (8 months ago) 
💥 CHALLENGE: Find a Collision in Leviathan v3.1 (Deterministic)
**The Context:**
I have officially deprecated SHA-2 and SHA-3. This decision stems from a critical security breach I witnessed: a virus that infected my system using forged digital signatures that were somehow validated as authentic by current standards. This proved that the 'trust' in existing hashing algorithms is compromised. Consequently, I have engineered Leviathan v3.1 Turbo to replace them with a system that doesn't just verify, but defends.

**The Logic:**
This algorithm uses a **Fractal Carry** system and a massive **10,000-digit Prime Constant** to ensure that even the slightest bit-flip in the input causes a catastrophic avalanche in the output.

**The Task:**
Simple. **Find a Collision.**
Find two distinct inputs (strings or byte arrays)  and  such that:



$$Leviathan(M_1) == Leviathan(M_2)$$

Where $M_1 \neq M_2$


**The Code:**
The algorithm is fully **DETERMINISTIC**. No random salts. Pure math.
**[Get the Source Code Here (OSF)](https://osf.io/8xb9h/files/aj92b)**

**Why you will fail:**

* The "Displaced Mutation Buffer" prevents linear collisions.
* The output space is **1024 characters**. The Pigeonhole Principle is on my side, not yours.
* The internal state evolves fractally, meaning  depends non-linearly on .

**Prize:**
The glory of breaking the first post-NIST hash algorithm.

**"Good luck. You'll need more than a supercomputer; you'll need a new dimension."**
code-golf