Concurrent Execution Using Shared Resource with Improper Synchronization ('Race Condition') (CWE-362)

Concurrent Execution Using Shared Resource with Improper Synchronization ('Race Condition')

The product contains a code sequence that can run concurrently with other code, and the code sequence requires temporary, exclusive access to a shared resource, but a timing window exists in which the shared resource can be modified by another code sequence that is operating concurrently.

This can have security implications when the expected synchronization is in security-critical code, such as recording whether a user is authenticated or modifying important state information that should not be influenced by an outsider.

Rozpowszechnienie

Średnia

Pokryto 3 języków

Wplyw

Wysoki

4 reguł o wysokim poziomie

Zapobieganie

Udokumentowane

6 przykładów poprawek

2 Zapobieganie

Jak naprawić tę podatność

Strategie zapobiegania dla Race Condition oparte na 6 regułach detekcji Shoulder.

🐹 Go Zobacz wszystko Go szczegóły →

Concurrent Slice Access HIGH

Protect concurrent slice access with mutex or use channels to collect results

+10 -7 go

  func collect(items []string) []string {
-     var results []string
-     for _, item := range items {
-         go func(i string) {
-             results = append(results, process(i))
-         }(item)
-     }
-     time.Sleep(time.Second)
+     resultsCh := make(chan string, len(items))
+     for _, item := range items {
+         go func(i string) {
+             resultsCh <- process(i)
+         }(item)
+     }
+     results := make([]string, 0, len(items))
+     for i := 0; i < len(items); i++ {
+         results = append(results, <-resultsCh)
+     }
      return results
  }

Direct Map Access on Thread-Safe Struct HIGH

Use thread-safe accessor methods or sync.RWMutex for concurrent map access

+1 -1 go

  func getNodeName(node *Node) string {
-     name, ok := node.Attributes["name"].(string)
+     name, ok := node.GetAttrString("name")
      if !ok {
          return ""
      }
      return name
  }

Potential Race Condition MEDIUM

Protect shared state with sync.Mutex, atomic operations, or sync.Map

+4 -4 go

- var counter int
- func increment() {
-     go func() {
-         counter++
+ var counter int64
+ func increment() {
+     go func() {
+         atomic.AddInt64(&counter, 1)
      }()
  }

🟨 JavaScript Zobacz wszystko JavaScript szczegóły →

Race Condition in Concurrent Operations HIGH

Use database transactions with row-level locking for atomic read-modify-write operations

+16 -3 javascript

  app.post('/withdraw', async (req, res) => {
-   const account = await Account.findOne({ where: { userId } });
-   if (account.balance >= amount) {
-     await account.update({ balance: account.balance - amount });
+   const transaction = await db.transaction();
+   try {
+     const account = await Account.findOne({
+       where: { userId },
+       lock: transaction.LOCK.UPDATE,
+       transaction
+     });
+     if (account.balance < amount) {
+       await transaction.rollback();
+       return res.status(400).json({ error: 'Insufficient funds' });
+     }
+     await account.update({ balance: account.balance - amount }, { transaction });
+     await transaction.commit();
+   } catch (e) {
+     await transaction.rollback();
+     throw e;
    }
  });

🐍 Python Zobacz wszystko Python szczegóły →

Potential Race Condition MEDIUM

Use locks for shared data and atomic operations for file access

+6 -4 python

  import threading
  
  counter = 0
- 
- def increment():
-     global counter
-     counter += 1
+ lock = threading.Lock()
+ 
+ def increment():
+     global counter
+     with lock:
+         counter += 1
  
  threads = [threading.Thread(target=increment) for _ in range(100)]

Kluczowe praktyki

Use data races, lost data, or panics
Use race conditions
Use of sync

3 Wykrywanie

Znajdz podatnosci w swoim kodzie

Uzyj Shoulder do skanowania kodu w poszukiwaniu wzorcow Concurrent Execution Using Shared Resource with Improper Synchronization ('Race Condition'). 6 reguly.

terminal

# Scan with Shoulder CLI
npx @shoulderdev/cli trust --cwe=362

# Or scan entire project
npx @shoulderdev/cli trust .

Reguly Wykrywania (6)

🐹 Go 4 rules

Concurrent Slice Access HIGH

Concurrent access to slices (especially append) without synchronization can cause data races, lost data, or panics. Slices in Go are not thread-safe.

Direct Map Access on Thread-Safe Struct HIGH

Direct access to map fields on structs that provide thread-safe accessor methods can cause race conditions. Use the provided accessor methods instead.

Potential Race Condition MEDIUM

Shared data accessed from goroutines without synchronization.

WaitGroup Misuse HIGH

Improper use of sync.WaitGroup can cause race conditions, panics, or deadlocks. Common issues include calling Add() inside goroutines and Done() count mismatches.

🟨 Javascript 1 rules

Race Condition in Concurrent Operations HIGH

Detects time-of-check to time-of-use (TOCTOU) vulnerabilities where the state can change between checking a condition and acting on it. Common race conditions include: - Check balance, then deduct (balance can change in between) - Check inventory, then create order (stock can be sold out) - Check permissions, then perform action (permissions can change) - File existence check, then read/write (file can be modified)

🔷 Typescript 1 rules

Race Condition in Concurrent Operations HIGH

🐍 Python 1 rules

Potential Race Condition MEDIUM

Detects potential race conditions in concurrent Python code. Common race condition patterns: 1. Global variables accessed from threads without locking 2. TOCTOU (Time-of-check Time-of-use) file operations 3. Shared data structures modified in threads without synchronization 4. Check-then-act patterns without atomicity Python's GIL doesn't prevent all race conditions, especially with I/O operations and multi-process code.

4 Sygnaly Ostrzegawcze

Na co zwracac uwage podczas przegladu kodu

Te wzorce wskazuja na potencjalne podatnosci Concurrent Execution Using Shared Resource with Improper Synchronization ('Race Condition'). Szukaj ich podczas przegladow kodu i audytow bezpieczenstwa.

🟠

Concurrent slice access without synchronization causes data races. append() is NOT atomic - multiple goroutines appendin go-concurrent-slice-access

🟠

Direct access to map fields can cause race conditions in concurrent code. Maps in Go are not thread-safe, and concurrent go-direct-map-access

🟠

Improper WaitGroup usage can cause: - Race conditions (Add inside goroutine) - Panics (negative counter from Done miscou go-waitgroup-misuse

🟠

Race condition at ... - check and act are not atomic javascript-race-conditions

🟠

time-of-check to time-of-use (TOCTOU) vulnerabilities where the state can change between checking a javascript-race-conditions

🟡

Shared data accessed without proper synchronization go-race-condition

🟡

potential race conditions in concurrent Python code python-race-condition

🔍

Przeskanuj swój kod w poszukiwaniu Concurrent Execution Using Shared Resource with Improper Synchronization ('Race Condition')

Shoulder CLI znajduje podatne wzorce w całym Twoim kodzie.

npx shoulder trust Przeglądaj wszystkie reguły