Opecon

AI Enthusiast

[Opecon @0xgod_Speed]

@pashov Why isnt Claude and Vscode on this list 🤔🤔

[Opecon @0xgod_Speed]

@Smacaud1 All u have to do is use a brand new pc, u'll be covered 🤣😂

[GothamChess @GothamChess]

I've been sitting here numb for the past hour staring at this news. The world lost a brilliant man today. May his memory live on forever and may we always cherish his contributions to our beautiful game.

[Charlotte Chess Center @CLTchesscenter]

The Naroditsky family shares the sad news of Daniel’s unexpected passing. Daniel was a talented chess player, educator, and beloved member of the chess community. We ask for privacy as the family grieves.

[Opecon @0xgod_Speed]

@Tigerfrake Congrats bro

[Opecon @0xgod_Speed]

@Smacaud1 😂😂😂

[Opecon @0xgod_Speed]

@shealtielanzz Absolutely shocked !!!

[brainiac5 @shealtielanzz]

For $200k!
This is another level of raising the bar too high😅

[Matt | Mustby.eth @mustby]

For @PatrickAlphaC!

✅ Benching 225
✅ Verifying the calldata in a transaction
✅ Saying the .env pledge

After three hours of pickleball!

Back to the Cyfrin grind after this 💪

#CyfrinStudent

[pashov @pashov]

1st of June. If you are reading this, I wish that this month is your best one so far in web3 security in terms of vulnerabilities found and protected, revenue & winnings and relationships built.

We are currently in the bull run of web3 security. DO NOT sleep on it.

[tpiliposian @tpiliposian]

Web3 security beginner mistake #9

You’re not a developer, you’re a hacker, so

Don’t check if the code is written correct. Check what’s written wrong.

Don’t trust the docs or comments, anything can go wrong, and often does, find what breaks, and how big it breaks.

[ChaseTheLight @ChaseTheLight99]

LightChaser is often used to generate known issues lists and the response/results I've seen indicates LightChaser is getting closer to achieving this. I do believe in due time LightChaser will achieve goal (1).

My current mission statement is to get LightChaser to a competency point where it can perform well in contests, this is my primary focus. I don't really market as much as I should and I mostly just focus on having a small core clientele that I can provide a good service to. This is so I can spend most of my time developing LightChaser. I feel that provided I don't get complacent and keep working towards this mission statement, goal (3) will also be achievable by LightChaser.

Like Dacian stated, I don't feel automated audits can replace manual audits, they are another stage in the overall process. On my website, I have a section that clearly states that LightChaser is one stage followed by team manual audits, competitive audits and a bug bounty program.

LightChaser doesn't use AI or LLMs. I personally believe that in the long run static and dynamic analysis will be the most reliable security automation. I've done a lot of experiments with AI and I still feel traditional static analysis with a good framework and a large array of detectors perform better for most protocols. I also personally believe that static/dynamic based detection will achieve goal (1) and (3) before LLMs do.

I made a tweet about this a while back with a similar question. My advice is not to let these BS 'AI AUDIT Adapt or Die' type people and firms discourage you from auditing, they are almost all lying and just trying to ride the AI hype train. I even said in that tweet that if their tech was so good, why don't they use it to compete?

You will not be replaced anytime soon!

[ddimitrov22 @ddimitrovv22]

This is still one of the most fun places to study bugs.

If you ever find yourself bored, just roll a few findings and study them in depth.

Use it instead of any mindless scrolling social media apps and you'll improve much quicker.

https://t.co/fOYUV0kbbJ

[deadrosesxyz @deadrosesxyz]

Yieldoor will literally dominate.

It will have something for all risk profiles, optimized to the fullest.

once you give it a chance, there'll be no going back to any other protocol.

[chrisdior @chrisdior777]

Top 5 qualities I’ve noticed every killer Web3 team has:

1. High energy that fuels action
2. Relentless hustle to keep pushing
3. The grit to bounce back from setbacks
4. A shared vision that unites everyone
5. Openness to criticism for constant growth

[Opecon @0xgod_Speed]

@pashov Amen to that

[TrustSec @TrustSecAudits]

If facts are true, this is shameful and borderline criminal behavior by @Scroll_ZKP . Clear chain freeze PoC at near-zero cost and they close report, then offer $1k in a $1M bounty? How does deprecating the feature next month qualify for the "no-fix, no-pay" policy? Unfortunately we're at a point where this treatment has become the default, and white hats already imagine what kind of tricks the project will use to get away from paying the bounty.

The hardest thing to understand is how some projects are happy to spend six or seven figures on audits, but will argue for days, ghost, and lie, just to avoid paying a tiny fraction of that, for a concrete missed exploit. I suspect the answer is more psychological than based on sound reasoning.

Since we cannot trust projects' good will by default, and many mediation services are continually being extremely lenient on the side of projects, the only weapon white hats have left is PR. It seems the sustainable solution is that projects should be dead scared of being held accountable and having their reputation destroyed.

Of course one should never generalize and there are many honorable projects, many of which can be found in our bounty cabinet.

As always it's important to hear both sides, but that's difficult when one of them hides behind confidentiality clauses and refuses to comment. Bounty platforms should have a mandatory unsealing process triggered after a fix or sufficient time elapsed, ensuring all parties are held accountable. Until then, we'll keep exposing malicious projects as much as we legally can.

[Andy Li @andyfeili]

Found a live bug in EigenLayer (this was a few days before the cantina contest). It was discovered during reviewing the offchain sidecar rewards calculation.

[CharlesWang @0xCharlesWang]

A small story about my auditing journey

First Step: Line-by-Line Auditing

When I first started auditing, my approach was extremely standardized. I audited each contract line by line, understanding the business logic, function by function.

At this stage, I was focused on grasping what each function did and how it fit into the larger functionality. However, this line-by-line approach, while thorough, had limitations:

Missed Vulnerabilities: Some bugs, especially complex ones involving cross-functional or state-based logic, can simply not be found by using this approach only.

Difficulty Seeing the Big Picture: Focusing so closely on individual lines of code made it challenging to understand the contract’s broader design or how different parts interacted.

At this stage, I was building foundational skills, understanding syntax, structure, and the logic behind various functions, but I hadn’t yet developed a method to catch some of the more complex or nuanced vulnerabilities.

It was an extreme hard process during this phase because the resources how to learn solidity (let alone auditing) were extremely limited (I bought some courses on Udemy back then)

Second Step: Introducing Function Jumping and State Differentiation

In my second step, I adapted my process to address the limitations of pure line-by-line auditing. I began to jump between functions, tracking how different functions connected and interacted with each other. This shift helped me get a better grasp on state management within contracts:

Better Contextual Awareness: By understanding the interconnections between functions, I was able to identify vulnerabilities in the transitions between contract states.

Functionality-Based Auditing: Instead of focusing on individual lines in isolation, I started viewing functions as part of a broader context. This enabled me to uncover logic issues that occur when functions are used together or in specific sequences.

This approach helped me catch more bugs and improved my ability to analyze complex function interactions. At this point, I had developed a more holistic view of the code but the ability to efficiently spot game-theoretical issues or vulnerabilities in contract states was still not perfect.

Third Step: Initial Assessment Through State Separation

During the third step, I began my audits with an initial assessment based on contract states. With more experience, I found that I could identify potential weaknesses simply by mapping out the different states and interactions:

Preliminary Bug Identification: During this initial assessment, I could already find bugs simply by categorizing and understanding contract states. The process of separating and analyzing these states made many vulnerabilities clear right from the start.

Pattern Recognition and Sensitivity: Experience had taught me to recognize patterns and identify areas that were likely to contain vulnerabilities. Certain coding patterns or state transitions became red flags, and I intuitively knew where to look. This must not be mixed up with pattern matching which most auditors do these days.

This shift in focus allowed me to understand the contract’s dynamics more deeply, making it easier to uncover vulnerabilities in the broader logic rather than just in isolated functions. At this stage, I started uncovering more sophisticated bugs and edge cases, especially those related to state transitions and variable sensitivity.

Fourth Step: Freestyle Auditing and Intuition-Driven Leads

During the fourth step, my approach had become highly intuition-driven. I no longer felt the need to start at the beginning of a contract or follow a strict line-by-line order. Instead, I started randomly within the architecture and spent the first few days exploring the codebase freestyle:

Lead-Based Auditing: Instead of systematically working through functions, I would list potential leads, following my intuition to areas that I suspected might have vulnerabilities. Interestingly, the intuition was by that time already so great that I can find multiple leads / potential leads within the first few minutes.

Deep Architectural Understanding: This freestyle approach gave me a great understanding of the contract’s architecture. I began to uncover game-theoretical scenarios and complex vulnerabilities that might have been hidden in conventional audits.

High Success Rate of Intuition: At this point, my intuition had become a critical tool. Years of experience meant that I could sense which areas of the code were likely to contain vulnerabilities. I would often uncover significant issues based purely on this intuition.

This evolution of my approach meant that I could assess not only the security of individual functions but the security of the entire protocol’s structure and intent, including very sophisticated issues which were hard to explain “how I found them”.
I reached a point where I was confident enough to say that with sufficient carefulness and time, I am able to uncover around 95% of all issues. This has proven itself again and again when participating in team audits.

This does not mean that my auditing approach these days is purely based on intuition and freestyle auditing. It's only one part of many parts of my methodology for a full audit.

Reflection: How Experience Shapes Auditing Approaches

Over the years, my auditing approach transformed from a detailed, line-by-line process to one driven by intuition and architectural understanding. As I gained experience, I learned that while foundational skills and systematic approaches are crucial in the beginning, intuition and a deep understanding of contract dynamics become invaluable tools for discovering the most sophisticated vulnerabilities.
As knowledge and experience grow, an auditor’s intuition becomes one of the most reliable resources. This intuition enables us to see beyond the syntax and dive into the underlying logic and strategy of the code, revealing vulnerabilities that are nearly invisible in standard audit. There are some really great issues which other team members couldnt even reproduce when I told them exactly where to look for and what to look for, simply because reproducing the bug needed a few different, consecutive state transitions before it became visible.