A multi-factor anti-fraud detection method based on the intersection of historical device fingerprint sets
By combining dual-rule sliding window management, global fixed salt value SM3 salted hash desensitization, and Bloom filter prediction with a multi-factor weighted decision-making method based on precise intersection, the shortcomings of existing anti-fraud detection technologies in terms of anti-bypass capability, false alarm rate, storage overhead, and privacy compliance are solved, achieving efficient and secure anti-fraud detection.
Patent Information
- Application Number
- CN202611199455.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-10
- Publication Date
- 2026-11-17
AI Technical Summary
Existing anti-fraud detection technologies are insufficient in terms of bypass resistance, false positive rate, storage overhead, and privacy compliance, and cannot simultaneously meet the technical requirements of high bypass resistance, low false positive rate, low storage overhead, and privacy compliance.
A multi-factor weighted decision-making method combining dual-rule sliding window management, globally fixed salt value SM3 salted hash desensitization, and Bloom filter prediction with precise intersection is adopted. The sliding window controls the data scale, salted hashing ensures data security, Bloom filter optimizes the efficiency of intersection operation, and multi-factor cross-validation reduces the false alarm rate.
It significantly improves the ability to identify device rotation fraud, reduces storage and computing costs, effectively reduces false alarm rates, and ensures data privacy and security.
Smart Images

Figure CN123122884A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of internet anti-fraud detection technology, specifically to a multi-factor anti-fraud detection method and system based on the intersection of historical device fingerprint sets. It can be applied to computer security detection scenarios that require comparing the association of fingerprints from multiple user devices, such as recommendation relationship verification, login risk identification, anti-fraud of marketing activities, and transaction risk control. Background Technology
[0002] Existing anti-fraud detection technologies mainly suffer from the following technical shortcomings: | Number | Defect | Details | |------|------|------| | 1 | Poor Bypass Resistance of Single-Point-of-Time Detection | Most existing solutions only compare the device identifier of the current single data collection. Attackers can easily bypass this by changing devices, switching accounts, or using emulators. | | 2 | High false alarm rate in single-dimensional detection | High probability of false positives for single detection factors (such as IP address only or device ID only): overlapping IPs of multiple users in a shared network environment, and overlapping device IDs due to device borrowing | | 3 | Excessive storage overhead due to full storage | Existing solutions lack systematic management of historical fingerprint data: full storage causes storage overhead to increase linearly with the number of users, and the performance of aggregate operations decreases linearly with the amount of data. | 4 | Privacy Compliance Risks | Some solutions directly collect and store plaintext data such as original hardware information and personal identification information of user devices, posing data privacy compliance risks; and lack data anonymization and expiration cleanup mechanisms. Existing anti-fraud methods based on historical device fingerprint sets only store the user's full historical device IDs and do not use a dual-rule sliding window to control the data size, resulting in high storage overhead; they do not use Bloom filters to optimize the efficiency of intersection operations, resulting in low detection performance; and they rely solely on single-factor determination of device fingerprints, leading to a high false alarm rate.
[0003] In summary, existing technologies cannot simultaneously meet the technical requirements of "high resistance to bypass, low false alarm rate, low storage overhead, and privacy compliance".
[0004] | Comparison Dimensions | Existing Technology (Device Fingerprint History Set Anti-fraud) | Existing Single-Point-of-Time Single-Factor Scheme | This Invention | |----------|-------------------|------------------|--------| | Fingerprint Management Method | Full storage, no automatic expiration | Only stores the current single-collection value | Dual-rule sliding window (number of fingerprints threshold + time expiration + deduplication update) | | Data anonymization | Not publicly disclosed | Direct hashing or no anonymization | Global fixed salt value + SM3 salted hash | | Detection Methods | Intersection of Two-User Historical Sets (Single Factor) | Single-Point-Time Comparison (Single Factor) | Bloom Filter Prediction + Exact Intersection + Multi-Factor Cross-Validation | | Performance Optimization | None | None | Bloom filter O(k) prediction, quickly skipping precise calculations for non-overlapping user pairs | | Decision-making method | Risk is determined by the intersection not being empty | Single-factor threshold determination | Core factor-driven (W1≥W2+W3+W4, core factor priority in case of tie) weighted + three-level threshold decision-making | | Single-user storage usage | Full data usage, increasing over time | Only current value stored | Fixed upper limit of N_max entries (deduplication + eviction + expiration) | | Recall | Low (single-factor intersection only) | Low (single-time point comparison only) | High (historical set intersection + multi-factor cross-validation) | | False Alarm Rate | High (single factor overlap is sufficient for detection) | High (single time point value same is sufficient for detection) | Low (dual-channel cross-validation, single channel cannot trigger high risk) | | Single request time | ~8ms | ~5ms | Microseconds (Bloom filter prediction + exact intersection) | | Multi-scenario adaptation | Recommended binding only | Single scenario | Configurable for four scenarios: recommended binding / login / event / transaction | | Rainbow table attack resistant | None (direct hashing) | None | Salted hashing | Existing anti-fraud methods based on the intersection of historical device fingerprint sets only store the user's full historical device IDs, do not employ dual-rule sliding windows to control data size, do not use Bloom filters to optimize intersection calculation efficiency, and rely solely on single-factor determination of device fingerprints. This invention solves four technical problems in existing technologies—high storage overhead, low detection efficiency, high false alarm rate, and weak resistance to rainbow table attacks—through the organic combination of five technical features: dual-rule sliding window + salted hash desensitization + Bloom filter prediction + precise intersection + multi-factor weighted decision-making dominated by core factors. These five features are interconnected: the sliding window controls the input data size, making the bit vector length of the Bloom filter configurable; the Bloom filter prediction reduces the computational load of precise intersection, enabling multi-factor weighted calculations to be completed in milliseconds; and salted hashing ensures the security of the accumulated data in the sliding window, collectively forming a complete technical chain. Summary of the Invention
[0005] 3.1 Technical problems to be solved 1. Addressing the technical problem of poor bypass resistance in single-time point detection: Attackers can bypass fingerprint comparison at the current moment by switching devices. A method is needed that can utilize the user's complete device usage history for cross-verification, fundamentally improving the ability to identify multi-device switching fraud. 2. Addressing the balance between the overhead of historical fingerprint data storage and detection coverage: Full storage leads to storage bloat and decreased query performance; insufficient storage, on the other hand, affects detection coverage. A data management mechanism is needed to automatically discard expired data while retaining sufficient detection features. 3. Addressing the technical challenge of high false positive rates in single-dimensional detection: The overlap of a single factor is insufficient to determine fraud; a multi-dimensional cross-validation mechanism is needed to reduce the probability of false positives while ensuring that computational costs remain within acceptable limits. 4. Addressing the performance bottleneck of large-scale set intersection operations: With millions of users, the computational cost of accurate intersection operations between pairs of users is enormous. It is necessary to significantly reduce computational overhead while maintaining detection accuracy. 3.2 Technical Solution This invention adopts a combined technical architecture of "dual-rule sliding window fingerprint management + global fixed salt value SM3 salted hash desensitization + Bloom filter pre-judgment bound to sliding window capacity + precise intersection core detection + multi-factor weighted decision dominated by core factors (W1≥W2+W3+W4)".
[0006] Technology contribution chain: Technical Issue 1: Single-point-of-time detection cannot identify device rotation fraud—attackers can bypass fingerprint comparison at the current moment by changing devices. ↓ Technical Method 1: Accumulating historical fingerprints using a dual-rule sliding window + globally fixed salt value SM3 salted hash desensitization + dual-user set intersection operation ↓ Technical benefit 1: Even if a user is currently using a brand new device, it can be identified as long as any device in the user's history overlaps with the other party's, significantly improving the recall capability against device rotation fraud. Technical Issue 2: Full storage leads to excessive storage overhead in large-scale user scenarios, and query performance decreases linearly with the amount of data. ↓ Technical Method 2: A dual-rule sliding window management system using a threshold of 50 entries and an expiration date of 180 days, combined with deduplication and updates. ↓ Technical benefit 2: The number of records stored by a single user is limited to N_max records, preventing the historical fingerprint data from expanding indefinitely. Technical Issue 3: The computational cost of exact intersection operations on large-scale sets is enormous. ↓ Technical Method 3: Bloom filter bit mapping prediction tied to sliding window capacity (bit vector length m is tied to N_max, hash function number k is calculated and rounded according to the formula k=(m / N_max)×ln2), skipping precise calculation when there is no intersection, and the false positive rate of a single element can be quantified by the standard Bloom filter formula. ↓ Technical effect 3: Bloom filter prediction allows the detection of non-overlapping user pairs to skip precise calculations, significantly reducing the average request time. Technical Issue 4: High false alarm rate in single-dimensional detection (misjudgment of a single factor due to shared IP or borrowed equipment) ↓ Technical approach 4: Multi-factor weighted scoring of core factor (weight 0.5) + three auxiliary factors (weights 0.25 + 0.125 + 0.125) + three-level threshold decision-making. ↓ Technical benefit 4: Through multi-factor cross-validation, maximizing any single dimension alone will not trigger a high-risk judgment (dual-channel validation mechanism), effectively reducing the false alarm rate. 3.2.1 Multi-dimensional device fingerprint acquisition and salted hash desensitization Each time a user performs a preset triggered action (including but not limited to login, registration, and critical operations), the system automatically collects multi-dimensional device feature data, including at least three types of fields: | Feature Category | Content Collected | Technical Application | |---------|---------|---------| | Device Hardware Characteristics | Unique Device Identifier, Browser Fingerprint Hash, Client Environment Identifier | Device Identity Verification | | Network Environment Characteristics | Client IP Address, Network Type, Carrier Information | Network Correlation Analysis | | System Environment Characteristics | Operating System Version, Screen Resolution Parameters, System Language | Environment Consistency Verification | Salted hash desensitization mechanism: Due to the limited value space of features such as device operating system version and screen parameters (e.g., operating system version has only dozens of possible values), direct one-way hashing carries the risk of rainbow table reverse engineering. This invention adopts a globally fixed salt value salting mechanism: the system presets a globally fixed salt value (uniform for all users). Each time data is collected, the original feature data is concatenated with the global salt value (format: SM3(raw_feature + global_salt) or SHA256(raw_feature + global_salt)), and then a one-way hash operation is performed. This embodiment preferably uses the SM3 hash algorithm (output 256 bits), while SHA-256 is an optional alternative implementation. The globally fixed salt value ensures that the same device generates a consistent hash value among different users, which is a prerequisite for the intersection operation of cross-user device fingerprint history sets. The server only stores the SM3 salted hash value for device hardware identifiers and system environment characteristics, and does not retain this part of the original plaintext. The IP address field in the network environment characteristics needs to support cross-user IP association analysis (F2 shared IP history, F4 same IP account density factor), so its original value is stored separately. This value, along with the anonymized device fingerprint hash value, is stored as separate fields in the storage structure. At the storage level, an additional user-level encryption layer can be added to enhance privacy protection.
[0007] The salted hash output space is 256 bits (SM3 / SHA-256 are both 2^256). Even if an attacker knows the operating system version of a device, they cannot reverse engineer or forge the hash value using a rainbow table because they cannot know the global salt value. The salt value is managed internally by a secure configuration and is not exposed externally.
[0008] 3.2.2 Dual-rule sliding window historical fingerprint collection management A separate set of device fingerprint history is maintained for each user, employing a dual-rule sliding window mechanism of "number of fingerprints threshold + time validity period," and deduplication updates are performed based on this. 1. Record Count Threshold Control: Set the maximum record count threshold N_max (configurable, typical value is 50 records). When a new fingerprint record is appended, if the total number of records in the set is greater than or equal to N_max, the record with the earliest acquisition time will be discarded. 2. Time Expiration Cleanup: Set the record validity period T_valid (configurable, typical value is 180 days). A background scheduled task scans the collection daily and deletes expired records whose collection timestamp is earlier than (current time - T_valid). 3. Deduplication Update: Before writing a new fingerprint feature, its feature hash value is compared with that of existing records in the set. If an identical feature hash value already exists, no new record is added; only the collection timestamp of that record is updated to the current time. This mechanism limits the maximum number of records a single user can store to N_max records, automatically cleaning up expired data to prevent unlimited growth. Each record contains at least three fields: {fingerprint_hash, ip_address, collected_at}. Deduplication updates ensure that repeated use of the same device does not result in wasted storage.
[0009] The data structure is defined as follows: A single device fingerprint record contains three fields: hash_value (a string that stores the fingerprint feature value after salting and hashing, using the SM3 or SHA-256 algorithm, and outputting a 64-character hexadecimal string); ip_address (a string that stores the IP address at the time of collection); and collected_at (an integer that stores the collection timestamp in Unix milliseconds).
[0010] The user device fingerprint history set is implemented using the Redis Sorted Set data structure: the key name format is fp:history:{user_id} (where {user_id} is replaced with the actual user identifier), the Score field stores the collected_at timestamp (used for sorting and range deletion), and the Member field stores the above three fields in JSON format ({"h":"hash_value","ip":"ip_address"}). The Sorted Set's Score-based sorting feature naturally supports eviction of expired records by time range, and its ZADD / ZRANGE / ZREMRANGEBYSCORE commands can efficiently perform deduplication, range queries, and deletion operations by time interval.
[0011] 3.2.3 Pre-judgment and exact intersection calculation of Bloom filter When any risk detection event is triggered, obtain the device fingerprint history sets of the two users to be detected, and execute the following detection process: Step 1: Pre-judgment of Bloom filter To reduce the overhead of intersection operations for large sets, a Bloom filter is first used for rapid prediction.
[0012] - Bit vector length m = N_max × ratio_m (ratio_m is a configurable scaling factor, typically ratio_m=10, e.g., m=500 when N_max=50); the specific value of m can be flexibly configured according to the precision and memory requirements of the business scenario. - The theoretical optimal number of hash functions is k_opt = (m / N_max) × ln(2) (when m=10×N_max, k_opt = 10 × ln(2) ≈ 6.93, rounded down to 7); the corresponding single-element false positive rate is p≈(1-e^(-7×50 / 500))^7≈0.82% according to the standard Bloom filter formula. In actual deployment, k=3 can be selected to reduce computational overhead. At this time, the single-element false positive rate is about 1.74%. This false positive only causes one more exact intersection operation to be performed, which does not affect the correctness of the detection result. - The false positive rate of the Bloom filter only affects the prediction stage. When two sets actually have no intersection, but the Bloom filter determines that there may be an intersection, only one additional exact intersection calculation is performed, which does not affect the accuracy of the final test result. Results where the Bloom filter determines that there is "definitely no intersection" are 100% correct, with no false negatives, and no additional error correction mechanism is needed. Each feature hash value in user A's historical set is mapped to a bit vector using k hash functions, and the corresponding position is set to 1. When detecting user B, each feature hash value of user B is mapped using the same k hash functions: if any mapping position of a feature hash value is 0, then that feature value is definitely not in user A's set; if at least one feature hash value in user B's set has all k mapping positions set to 1, then it is determined that the two sets may have an intersection (at this point, there is a false positive probability, i.e., there is no actual intersection, but BF mistakenly judges that there may be an intersection), and step 2 is performed to perform the exact intersection operation to eliminate false positives; if there is no feature hash value in user B's set that satisfies all k mapping positions set to 1, then according to the mathematical properties of Bloom filters, it is determined that the two sets definitely have no intersection, and the exact intersection operation is skipped directly, outputting "No risk of shared devices".
[0013] Step 2: Exact Intersection Operation When the Bloom filter determines that there may be an intersection, it performs an exact intersection operation on the history sets of the two users. Let the set of users A be S_A = {h_a1, h_a2, ..., h_am}, and the set of users B be S_B = {h_b1, h_b2, ..., h_bn}, and calculate the intersection S_intersect = S_A ∩ S_B.
[0014] The size of the intersection, n_intersect, is equal to |S_intersect|. If n_intersect > 0, then a risk of shared devices is identified.
[0015] 3.2.4 Multi-factor weighted comprehensive scoring and three-level risk decision-making Core Factor (Highest Weight): Shared Equipment Risk Score F1 The intersection result from step 2.3 is normalized and quantized: F1 = min(n_intersect / N_max, 1) × 100 Where n_intersect is the number of intersection elements, and N_max is the maximum number of records in the sliding window. F1 ranges from [0, 100], representing the risk level of shared equipment.
[0016] Auxiliary Factor 2: Shared IP Historical Risk Score F2 Extract all IP addresses from user A's historical fingerprint set to form IP_A, and extract all IP addresses from user B's historical fingerprint set to form IP_B: F2 = |IP_A ∩ IP_B| / max(|IP_A ∪ IP_B|, 1) × 100 The F2 value ranges from [0, 100]. The higher the proportion of users who have used the same IP address, the higher the risk.
[0017] Auxiliary Factor 3: Account Creation Time Risk Score F3 t = Current time - Account creation time of the user being monitored (unit: days) F3 = max(0, (1 - t / 7)) × 100 F3 values range from [0, 100]. Newly registered accounts within 7 days receive a high score, while those after 7 days are reset to zero (and are no longer considered time-sensitive risks).
[0018] Supplementary Factor 4: Risk Score for Same IP Account Density (F4) density = Total number of accounts historically associated with the current IP address F4 = min(density / 20, 1) × 100 F4 values range from [0, 100]. A score of 20 or more associated accounts is considered a full score (suspected IP farm).
[0019] Weighted overall score: S = W1 × F1 + W2 × F2 + W3 × F3 + W4 × F4 Preset weight values (supports dynamic adjustment): - W1 = 0.50 (Core factor, satisfying the constraint W1≥W2+W3+W4, is calculated by weighted summation of all factors in the comprehensive risk score. The weight of the core factor is not less than the sum of the weights of the auxiliary factors to ensure that the core judgment is not diluted by the auxiliary factors.) - W2 = 0.25 - W3 = 0.125 - W4 = 0.125 - Weight normalization: W1 + W2 + W3 + W4 = 1.0 Level 3 risk decision-making: IF S >= T_high (default 60): High risk → Reject operation, log alarm. ELIF S >= T_low (default 30): Medium risk → Allow operation + Mark for manual review ELSE: Low risk → Normal clearance Dynamic weight adjustment mechanism: At preset intervals (e.g., 7 days), based on manually verified fraud sample data within those intervals, the risk discrimination of each factor (e.g., information gain or KS statistic) is calculated. Weights are adjusted according to the discrimination ranking: factors with high discrimination have increased weights, while factors with low discrimination have decreased weights. The two thresholds, T_high and T_low, are optimized based on the balance between detection rate and false alarm rate (e.g., maximizing the detection rate while maintaining a false alarm rate ≤3%).
[0020] 3.2.5 Multi-scenario adaptation rules The rules for determining "two users to be detected" under different risk detection scenarios are as follows: | Detection Scenario | First User | Second User | Technical Purpose | |---------|---------|---------|---------| | Referral Relationship Binding | Inviter Account | Invited Account | Prevent Self-Invitation / Device Farm Reward Exploitation | | Login Verification | Currently Logged-in Account | Suspicious Accounts with Risk Associations within a Preset Time Window | Prevent Device Switching After Account Theft | | Marketing Campaign Participation | Currently Participating Accounts | Historical Fraud Blacklist Accounts | Prevent Blacklisted Users from Using Different Accounts to Participate | | Order Placement | Current Order Account | Other Order Accounts from the Same IP / Device Within the Last 24 Hours | Preventing Bulk Fraudulent Transactions | 3.2.6 Exception Handling and Boundary Conditions | Scenario | Processing Rules | |------|---------| | User's historical fingerprint set is empty (new user) | Shared device risk score F1 is recorded as 0, continue collecting and accumulating fingerprints; this will automatically take effect when subsequent operations trigger detection. | | Bloom Filter False Positives | False positives only result in one extra exact intersection calculation and do not affect the accuracy of the test results (Bloom filter does not have false negatives; a no-intersection result is considered a true no-intersection result). | The sliding window is empty (all records have expired) | It is considered that the history set is empty, F1=0 | | Client fingerprint reporting has been tampered with | The salted hash mechanism ensures that the forged hash value cannot be matched with the historical records stored on the server. The intersection operation result is 0, and the risk score will not increase abnormally. | Salt Value Leakage | Global salt values are managed in a secure configuration format and can be rotated periodically; user-level encryption is overlaid on the storage layer to enhance protection. | | Weight Adjustment Oscillation | Set a maximum step size limit for weight adjustment (no more than ±0.05 per adjustment) to avoid drastic weight fluctuations caused by single-cycle noise. 3.3 Key Innovations 1. Fingerprint Management Data Structure with Global Fixed Salt Value + SM3 Salted Hash Desensitization: Unlike existing technologies that only perform simple hashing or use desensitization schemes that affect cross-user comparison consistency, this invention uses a globally fixed salt value to perform SM3 salted hash operation on the original device features (outputting 256 bits), storing only the hash value and not retaining the plaintext. The globally fixed salt value ensures that the same device generates consistent hash values across different users, which is a prerequisite for cross-user device fingerprint set intersection operation; at the same time, the 256-bit output space of SM3 one-way hash fundamentally eliminates rainbow table reverse engineering and hash collision attacks. Combined with a dual-rule sliding window mechanism of number threshold + time validity period (including deduplication update), the storage occupation of a single user is limited to within N_max (typically 50, about 4KB), which is significantly reduced compared to full storage. At the storage level, an additional user-level encryption layer can be added to balance cross-user comparison consistency and storage privacy. 2. A two-stage intersection detection algorithm for Bloom filters bound to sliding window capacity: Unlike existing technologies that use Bloom filters as a general set prediction tool, this invention directly binds the Bloom filter parameters to the sliding window capacity: bit vector length m = N_max × ratio_m (ratio_m is configurable), and the number of hash functions k = (m / N_max) × ln2 (rounded down). Utilizing the mathematical property that Bloom filters have no false negatives—all results determined to be definitely non-intersecting are 100% correct—the exact intersection operation is skipped, reducing computational overhead. This design ensures that the Bloom filter accuracy automatically adapts to the sliding window size, eliminating the need for manual parameter tuning. False positives (misjudging non-intersecting sets as potentially intersecting sets) only result in one extra exact intersection operation, without affecting the accuracy of the detection result. Existing technologies combining Bloom filters and sliding windows are applied to single-user anomaly detection rather than dual-user intersection prediction scenarios. 3. Dual-channel cross-validation weighted architecture with core factor weight not less than the sum of auxiliary factor weights: Unlike existing conventional equal-weight or empirical weighting schemes, this invention adopts a constraint rule that the core detection factor weight is not less than the sum of all auxiliary factor weights (W1≥W2+W3+W4, typical values W1=0.50, W2=0.25, W3=0.125, W4=0.125). Under the typical configuration of W1=W2+W3+W4, the maximum contribution of the core factor alone is 50 points, and the maximum contribution of all auxiliary factors combined is also 50 points. High-risk judgment requires both the core factor and auxiliary factor channels to increase simultaneously to trigger (T_high=60). Maxing out any single channel alone will not trigger high risk, forming a dual-channel cross-validation mechanism—ensuring that the intersection evidence of device fingerprints has a weight not less than the sum of all auxiliary factors, and eliminating false positives caused by extreme values in a single dimension from the mathematical model level, effectively reducing the false alarm rate from the mathematical model level. This weight constraint rule has not been disclosed in existing publicly available multi-factor weighting frameworks. 3.4 Performance Verification Data The following data is based on actual test results using the SHA-256 hash algorithm in a Python 3.10 environment (Intel Xeon E5-2670 v3, 16GB RAM): (1) False positive rate verification of Bloom filter: When parameters m=500, k=7, n=50, the measured false positive rate of 30 independent tests was 1.13% (std=0.19%), which is on the same order of magnitude as the theoretical value of the standard Bloom filter formula p≈(1-e^(-7×50 / 500))^7≈0.82%, meeting the accuracy requirements of the prediction stage. When parameters m=500, k=3, n=50, the measured false positive rate was 1.80% (std=0.12%), which is basically consistent with the theoretical value of 1.74%.
[0021] (2) Bloom filter operation time: about 4.5us for a single insertion and about 3.7us for a single query. The total time for BF prediction and exact intersection operation for 50 historical records for each user is about 273us, of which the BF prediction part is about 185us and the exact intersection part is about 88us.
[0022] (3) Core cryptographic operation time: SHA-256 hash calculation takes about 1.6us / time (64B data); SM3 hash calculation has the same performance as SHA-256, reaching the microsecond level.
[0023] (4) Storage usage analysis: Each device fingerprint record contains a 64-character (256-bit) hexadecimal hash value and a collection timestamp. The storage overhead for a single record is approximately 80 bytes. Under the dual-rule sliding window (maximum 50 records), the maximum storage usage for a single user is approximately 4KB. In actual use, considering deduplication updates and expired data removal, the average usage is significantly lower than the upper limit. Attached Figure Description
[0024] Figure 1 This diagram illustrates the timeline of device fingerprint collection and accumulation. The horizontal axis represents time, marked with five time points: T1 login, T2 registration, T3 participation in activities, T4 transaction initiation, and T5 login again. It displays the device and network combination information collected at each time point. A hash-desensitization layer is set at the top of the diagram, explaining that after SM3 salting and hashing, only the hash value of the device hardware and system environment characteristics is stored; the IP address retains its original value and is stored separately to support the calculation of auxiliary detection factors. The bottom of the diagram shows a sliding window-style historical set of device fingerprints, illustrating the rules for eliminating fingerprints based on the number of records, cleaning up expired records, and deduplication updates.
[0025] Figure 2 This is a flowchart illustrating the overall process of multi-factor risk assessment. It shows that starting from the triggering of a risk detection event, the system acquires the device fingerprint history sets of two users and then calculates four types of risk factors in parallel: the core factor is the intersection of device fingerprint history; auxiliary factor 1 is shared IP history detection; auxiliary factor 2 is account creation time detection; and auxiliary factor 3 is same IP account density detection. Subsequently, each factor is weighted and comprehensively scored. Finally, based on the score range, three decision results—high risk, medium risk, and low risk—are output. The bottom notes indicate that the weights and thresholds can be dynamically adjusted, and the detection scenarios are scalable.
[0026] Figure 3 This diagram illustrates the intersection operation of device fingerprint history sets, presented as a Venn diagram. User A's set contains device ID-A1 / IP-1, device ID-A2 / IP-2, and device ID-A3 / IP-3; User B's set contains device ID-B1 / IP-4 and device ID-B2 / IP-5. The intersection region is device ID-A1 / IP-1. The intersection operation formula and the function of the Bloom filter preprocessing are explained below the diagram.
[0027] Explanation of each icon number: Figure 1901 - Device 1 + Network 1 (Device ID-A, IP-1, T1 Login), 902 - Device 1 + Network 1 (Device ID-A, IP-1, T2 Registration), 903 - Device 2 + Network 2 (Device ID-B, IP-2, T3 Participate in Activity), 904 - Device 1 + Network 3 (Device ID-A, IP-3, T4 Initiate Transaction), 905 - Device 3 + Network 3 (Device ID-C, IP-3, T5 Login Again), 906 - Hash De-identification Processing Layer, 907 - Sliding Window Type Device Fingerprint History Collection Figure 2 911 - Risk detection event triggered; 912 - Obtain device fingerprint history sets for two users respectively; 913 - Core factor (intersection of device fingerprint history); 914 - Auxiliary factor 1 (shared IP history detection); 915 - Auxiliary factor 2 (account creation timeliness detection); 916 - Auxiliary factor 3 (same IP account density detection); 917 - Weighted comprehensive score; 918 - High risk; 919 - Medium risk; 920 - Low risk Figure 3 921 - Fingerprint history set of user A device, 922 - Fingerprint history set of user B device, 923 - Intersection area, 924 - Intersection calculation formula, 925 - Bloom filter preprocessing instructions Detailed Implementation
[0028] 6.1 Sliding window-based device fingerprint management This embodiment corresponds to the fingerprint acquisition and historical data management module, and the overall timing is as follows: Figure 1 As shown.
[0029] 6.1.1 Multi-dimensional fingerprint acquisition and salted hash desensitization Each time a user logs in, registers, or performs a key operation (submitting an order, participating in an activity, or binding a relationship), the system automatically collects multi-dimensional device characteristics: - Device hardware characteristics: Unique device identifier (such as IDFA / OAID hash), browser Canvas fingerprint hash, device environment identifier generated by the client SDK. - Network environment characteristics: Client IP address, network type (WiFi / 4G / 5G), carrier information - System environment characteristics: operating system type and version number, screen resolution (width and height), system language settings The salted hashing process is as follows: The system pre-defines a globally fixed salt value (uniform for all users, managed through secure configuration, not exposed externally, and supported for periodic rotation). After each collection of raw device characteristics, the following steps are performed to perform salting and hash de-identification: Step 1, Feature Serialization: Sort all key-value pairs in the original feature dictionary in ascending order by field name, and concatenate them into a string using a vertical bar separator (format: "field name 1=value 1|field name 2=value 2|..."). Sorting in a fixed order ensures that the serialization results of the same device are consistent. The second step is to concatenate the salt value: concatenate the serialized feature string with the globally fixed salt value to obtain the input string to be hashed; Step 3: Perform SM3 hashing: Call the SM3 hash function to perform a one-way hash operation on the concatenated input string, outputting a 64-character hexadecimal hash value. This hash value has the following properties: the same device produces a completely consistent hash value across different users (a globally fixed salt value ensures cross-user consistency), which is a prerequisite for the intersection operation of cross-user device fingerprint sets; the 256-bit output space of SM3 ensures that attackers cannot reverse-engineer the original device characteristics from the hash value or forge the hash value using a rainbow table.
[0030] At the storage level, an additional symmetric encryption layer at the user level can be added to enhance privacy protection, and transparent decryption can be performed during intersection operations.
[0031] Because it uses a globally fixed salt value, the feature hash values of the same device are completely consistent across different users, which is a prerequisite for cross-user device fingerprint set intersection operations. Meanwhile, the 256-bit output space of SM3 one-way hashing prevents attackers from reverse-engineering the original device characteristics from the hash value. At the storage level, an additional user-dimensional symmetric encryption layer can be layered to enhance privacy protection; transparent decryption is performed during intersection operations.
[0032] 6.1.2 Dual-rule sliding window management The system uses a Redis Sorted Set to store each user's device fingerprint history set: - Key format: fp:history:{user_id} - Score: Collects timestamps (Unix milliseconds) - Member: JSON format {"h": "hash_value", "ip": "ip_address"} The execution steps of the sliding window management algorithm are as follows (parameter N_MAX=50 is the maximum number of records, T_VALID=180 days is the validity period, and the key name fp:history:{user_id} is the Redis Sorted Set key): Step 1: Deduplication check: Use the ZRANGE command to traverse all members in the existing set, parse the JSON data of each member, and compare the hash_value field of each member with the hash_value of the new fingerprint to be written. If a matching fingerprint is found, use the ZADD command to update the member's Score (collection timestamp) to the current time, without adding a new record, and the algorithm returns. Step 2: Add new record: If no duplicate fingerprints are found, serialize the new record into JSON format ({"h":"hash_value","ip":"ip_address"}), use the current collection timestamp as the score, and write it into the Sorted Set using the ZADD command; Step 3, record number threshold elimination: Use the ZCARD command to obtain the total number of records in the current set. If it exceeds N_MAX (50 records), use the ZREMRANGEBYRANK command to delete the redundant records with the smallest score (i.e. the earliest collection time) to keep the set size within N_MAX. Step 4: Time Expiration Cleanup (executed daily by a background scheduled task): Calculate the expiration deadline timestamp cutoff = current Unix millisecond time - T_VALID × 86400 × 1000, and delete all expired records with a score less than cutoff using the ZREMRANGEBYSCORE command.
[0033] 6.2 Multi-factor weighted anti-fraud detection This embodiment corresponds to the core detection and decision-making module, and the overall process is as follows: Figure 2 As shown.
[0034] 6.2.1 Pre-judgment of Bloom Filter Parameter calculation: Taking N_max = 50, ratio_m = 10, m = 10 × 50 = 500, according to the optimal number of hash functions formula k = (m / N_max) × ln(2) = 10 × ln(2) ≈ 6.93, the theoretical optimal rounding k = 7. The corresponding single-element false positive rate, according to the standard Bloom filter formula p≈(1-e^(-7×50 / 500))^7≈0.82%. Bloom filters do not have false negatives—all results judged as "definitely no intersection" are 100% correct—therefore, no additional error correction mechanism is needed. The specific values of the bit vector length m and the number of hash functions k are configurable parameters.
[0035] The specific implementation structure of a Bloom filter is as follows: A bit array is used as the underlying storage, and all bits are cleared to zero during initialization. Two instance variables are set: m (bit array length, default value 500) and k (number of hash functions, default value 7). MurmurHash3 is selected as the hash function family (suitable for Bloom filter scenarios due to its high speed and low collision characteristics). k independent hash functions are generated using different random seeds (seed=0,1,...,k-1). Each hash function calculates the hash value of the input string and takes the modulo m to obtain the position index in the bit array.
[0036] Adding element operation: For the string representation of the input element, k hash functions are called in sequence to generate k position indices, and the values of these positions in the bit vector are all set to 1.
[0037] Single-element query operation: For the string representation of the input element, generate k position indices using the same k hash functions, and check whether the values of these positions in the bit vector are all 1; if all are 1, return "may exist" (there is a probability of false positive), if any position is 0, return "definitely does not exist" (100% accurate, no false negative).
[0038] Set intersection prediction operation: Iterate through each fingerprint hash value in the historical set of the user to be detected, and call the single element query operation one by one; if there is at least one element in the set whose query result is "may exist", then it is determined that the two sets may have an intersection, and the precise intersection operation stage needs to be entered; if the query results of all elements are "definitely do not exist", then according to the mathematical properties of the Bloom filter, it is determined that the two sets definitely have no intersection, and the subsequent precise intersection operation is skipped directly.
[0039] 6.2.2 Intersection Operation and Risk Score Calculation When the Bloom filter determines that there may be an intersection, it performs an exact intersection operation. The specific steps are as follows: Step 1: Obtain the historical fingerprint hash value sets of both parties: Read all members of fp:history Sorted Set (ZRANGE key 0 -1) of user A and user B respectively from Redis, parse the "h" field (salted hash value) in the JSON string of each member, and extract it into hash value sets hashes_A and hashes_B; Step 2: Calculate the exact intersection: Find the intersection of hashes_A and hashes_B, and count the number of elements in the intersection, n_intersect. Step 3, Normalize the score: F1 = min(n_intersect / N_MAX, 1.0) × 100, which maps the number of intersections to the range of 0 to 100. N_MAX is the maximum number of records in the sliding window threshold (default 50). When the number of intersection elements reaches or exceeds N_MAX, F1 scores 100.
[0040] 6.2.3 Calculation of Auxiliary Factor Scores The specific steps for calculating auxiliary factor scores are as follows: Step 1: Extract IP Sets: Read all members of fp:history SortedSet for user A and user B from Redis respectively, parse the "ip" field in the JSON string of each member, and extract them into IP address sets ips_A and ips_B.
[0041] Step 2: Calculate F2 (Shared IP Historical Risk Score): Calculate the intersection size ip_intersect and the union size ip_union of ips_A and ips_B. F2 = ip_intersect / max(ip_union, 1) × 100, with a value from 0 to 100. The more times two users have used the same IP simultaneously, the higher the F2 value.
[0042] Step 3: Calculate F3 (Account Creation Time Risk Score): Obtain user B's account creation time and calculate the number of days the account has existed: account_age_days = (current Unix milliseconds time - account creation Unix milliseconds time) / 86400000, F3 = max(0, (1 - account_age_days / 7)) × 100, with a value ranging from 0 to 100. Newly registered accounts within 7 days have a higher score (close to 100), while those older than 7 days have a score of zero and are no longer considered as time-related risks.
[0043] Step 4: Calculate F4 (Account Density Risk Score): Obtain user B's current IP address (current_ip), query the cardinality of the set with key ip:accounts:{current_ip} in Redis (SCARD command), and obtain the total number of accounts historically associated with this IP (density). F4 = min(density / 20, 1.0) × 100, with a value from 0 to 100. A score of 20 or more associated accounts is considered full, used to identify IP farms (a large number of accounts sharing the same IP).
[0044] 6.2.4 Weighted Composite Scoring and Three-Level Decision Making The comprehensive risk score calculation is performed as follows: read the weight values of the four factors (W1, W2, W3, W4) from the weight configuration, multiply each factor score by its corresponding weight, and then sum them up, i.e., S = W1 × F1 + W2 × F2 + W3 × F3 + W4 × F4, and take the floating-point value as the result.
[0045] The decision-making logic for Level 3 risk is as follows: The comprehensive risk score S is compared with the preset high-risk threshold T_high (default 60) and low-risk threshold T_low (default 30). If S is greater than or equal to T_high, a high-risk decision is returned, the current business operation is blocked, and an alarm log is recorded. If S is greater than or equal to T_low but less than T_high, a medium-risk decision is returned, the current operation is allowed, and the event is marked in the background for manual review. If S is less than T_low, a low-risk decision is returned, and the operation is allowed normally without additional processing.
[0046] 6.3 Numerical Examples Scenario: Recommendation relationship binding detection - User A (the inviting party)'s historical fingerprint set: {Device A, Device B, Device C}, historical IP set: {IP1, IP2} - User B (the invitee)'s historical fingerprint set: {Device C, Device D}, account created only 5 minutes ago, current IP = IP2 Testing process: 1. Bloom filter prediction: User B's device C is matched in User A's Bloom filter → triggering exact intersection. 2. Exact intersection: n_intersect = 1 (shared by device C), F1 = min(1 / 50, 1) × 100 = 2.0 3. Shared IPs: IP_A = {IP1, IP2}, IP_B = {IP2}, intersection size 1, union size 2, F2 = 1 / 2 × 100 = 50.0 4. Account validity period: t = 5 / 1440 ≈ 0.0035 days, F3 = (1 - 0.0035 / 7) × 100 ≈ 99.95 5. IP Density: The current number of accounts associated with IP2 is 3. F4 = min(3 / 20, 1) × 100 = 15.0 6. Overall Score: S = 0.50×2.0 + 0.25×50.0 + 0.125×99.95 + 0.125×15.0 = 1.0 + 12.5 + 12.49 + 1.88 = 27.87 7. Decision: S < 30, deemed low risk, proceed normally. Analysis: Although there is overlap in devices and shared IPs, the number of overlapping devices is small (only 1), the account validity period is extremely short (normal new users), and the IP density is not high. The overall score is below the low-risk threshold, so normal users will not be mistakenly banned.
[0047] Scenario: Bulk registration fraud detection - User A (fraudulent account A) historical fingerprint set: {Device X}, IP={IP_farm} - User B (fraudulent account B) historical fingerprint set: {Device X}, IP={IP_farm}, account created only 1 minute ago. Testing process: 1. F1 = min(1 / 50, 1) × 100 = 2.0 2. F2 = 1 / 1 × 100 = 100.0 3. F3 = (1 - 1 / 1440 / 7) × 100 ≈ 100.0 4. The number of accounts associated with IP_farm is 85. Therefore, F4 = min(85 / 20, 1) × 100 = 100.0 5. S = 0.50×2.0 + 0.25×100 + 0.125×100 + 0.125×100 = 1.0 + 25.0 +12.5 + 12.5 = 51.0 6. Decision: If 30 ≤ S < 60, the risk level is determined to be medium. The operation is allowed, but it is marked for manual review. Note: In this scenario, only one shared device was detected (F1=2.0), but the three auxiliary factors—shared IP (100 points), account validity (100 points), and IP density (100 points)—all triggered the highest risk. The overall score of 51 points placed it in the medium-risk range and marked for manual review. If the number of shared devices used by the fraud gang continues to increase, the F1 score will gradually rise, and the overall score will increase accordingly. When the number of shared devices reaches a certain level, it will exceed the high-risk threshold. This solution ensures a high recall rate for device rotation attacks through a combination of gradual accumulation of core factors and rapid response of auxiliary factors.
[0048] 6.4 Security Analysis Attack scenarios | Attack methods | Defense mechanisms of this invention | |---------|---------|--------------| | Device Rotation Fraud | Attackers use virtual machines / emulators to continuously change device fingerprints | A sliding window accumulates all historical device fingerprints; if any historical device overlaps with the target account, it can be detected through intersection calculation. | | Proxy IP Pool Attack | Attackers use a large number of proxy IPs to hide their real IP address | Helper Factor F4 (Same IP Account Density) can identify abnormal correlation density in IP farms | | Bulk account registration | Attacker script for bulk account registration | Helper factor F3 (account creation time) can identify bulk registration behavior with extremely short creation times | | Rainbow table reverse hashing | Attackers pre-compute hash values of common device characteristics | The 256-bit output space of a globally fixed salt value + SM3 hash makes rainbow table pre-computation infeasible; the storage layer can be layered with user-dimensional encryption to enhance protection | | Fake device fingerprint reporting | Attacker tampers with client-collected data | The forged hash value cannot match the server's historical records (a valid hash can only be generated if the global salt value is also known), the intersection operation result is 0, and no false positive will occur | The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.
Claims
1. A multi-factor anti-fraud detection method based on the intersection of historical device fingerprint sets, characterized in that, Includes the following steps: S1. When a user performs a preset trigger operation, multi-dimensional device feature data is collected. The multi-dimensional device features include at least three types of fields: device hardware identifier, network environment features, and system environment features. The device hardware identifier and system environment feature fields in the original feature data are concatenated with a preset global fixed salt value, and then an SM3 salted one-way hash operation is performed. Only the generated desensitized fingerprint hash value is stored. The IP address field in the network environment features retains its original value and is stored separately to support subsequent cross-user IP association analysis and the calculation of auxiliary detection factors F2 (shared IP history) and F4 (same IP account density). The global fixed salt value is consistent for all users on the platform to ensure that the same device generates consistent feature hash values among different users and supports cross-user device fingerprint history set intersection operation. S2. Maintain an independent device fingerprint history set for each user, and manage the history set using a sliding window with two rules: a threshold for the number of records and a validity period. When a new fingerprint feature is written, if the same feature hash value already exists in the set, only the collection timestamp of the corresponding record is updated. If the total number of records in the set exceeds the preset maximum number of records, the record with the earliest collection time is discarded. Expired records with collection timestamps earlier than the preset validity period are deleted periodically. S3. When any risk detection event is triggered, determine the first user and the second user to be detected based on the event association rules, and extract the device fingerprint history sets of the first user and the second user respectively. S4. Use a Bloom filter to perform a two-stage intersection detection on the device fingerprint history sets of the first user and the second user: S41. Configure the length m of the Bloom filter bit vector to be 10 times the threshold N_max of the maximum number of records in the sliding window. The number of hash functions k is calculated and rounded according to the formula k=(m / N_max)×ln(2) (when m=10×N_max, k=10×ln2≈6.93, which is rounded to 7. The typical value is m=500, k=7), so that the false positive rate of a single element meets the preset anti-fraud detection accuracy requirements (p≈0.82% when k=7). Map all fingerprint hash values in the first user history set to the bit vector through k hash functions. S42. Map and verify each fingerprint hash value in the second user history set using the same k hash functions: If none of the fingerprint hash values has all k mapping positions set to 1, then the two sets are determined to have no intersection, and the detection result of no shared device risk is directly output; If at least one fingerprint hash value has all k mapping positions set to 1, then the two sets may have an intersection, and the exact set intersection operation is performed to count the number of intersection elements. The shared device risk score is calculated based on the number of intersection elements as the core detection factor F1. S5. Using the risk score of the shared equipment as the core detection factor F1, and combining it with three auxiliary detection factors: the historical risk score of the shared IP F2, the risk score of the account creation time F3, and the risk score of the same IP account density F4, a corresponding weight is preset for each detection factor. The weight of the core detection factor is no less than the sum of the weights of all auxiliary detection factors, i.e., W1≥W2+W3+W4 (typical value W1=0.50, W2+W3+W4=0.50). The core detection factor has a weight in the weighted score that is no less than the sum of all auxiliary factors. A high-risk judgment can only be triggered if the core factor and at least one auxiliary factor increase simultaneously (dual-channel cross-validation mechanism) to avoid misjudgment caused by noise from a single channel. The comprehensive risk score S is obtained by multiplying the risk scores of each detection factor by their corresponding weights and then summing them up. S = W1×F1 + W2×F2 + W3×F3 + W4×F4; Based on the comparison results of the comprehensive risk score with the first preset scoring threshold and the second preset scoring threshold, a three-level risk decision is output: high-risk interception, medium-risk marking and review, and low-risk release.
2. A multi-factor anti-fraud detection device based on the intersection of historical device fingerprint sets, characterized in that, include: The fingerprint acquisition and desensitization module is used to collect multi-dimensional device feature data when a user performs a preset trigger operation. It uses a globally fixed salt value (SM3) salted one-way hash operation on the device hardware identifier and system environment feature data to generate desensitized fingerprint features, ensuring that the same device produces consistent hash values across different users to support cross-user intersection comparison. The IP address field in the network environment features retains its original value and stores it separately to support cross-user IP association analysis and auxiliary detection factor calculation. The multi-dimensional device features include at least three types of fields: device hardware identifier, network environment features, and system environment features. The sliding window management module is used to maintain an independent set of device fingerprint history for each user. It manages the history set using two rules: a threshold for the number of fingerprints and a time validity period. It performs operations such as deduplicating and updating new fingerprints, eliminating old records when the number of fingerprints exceeds the limit, and periodically cleaning up expired records. The detection target determination module is used to determine the first user and the second user to be detected based on event association rules when any risk detection event is triggered, and to extract the device fingerprint history sets of the two users respectively. The intersection detection module is used to perform a two-stage intersection detection on the fingerprint history sets of two devices using a Bloom filter: the bit vector length m is configured to be 10 times N_max, the number of hash functions k is calculated and rounded according to the formula k=(m / N_max)×ln2 (k≈7 when m=10×N_max), and the false positive rate meets the preset anti-fraud detection accuracy requirements; if it is predicted that there will definitely be no intersection, the result of no shared device risk is directly output, and the precise intersection operation is skipped; if it is predicted that there may be an intersection, the precise intersection operation is performed, the number of intersection elements is counted and the shared device risk score is calculated; The multi-factor decision-making module uses the risk score of shared equipment as the core detection factor, combined with three auxiliary detection factors: the historical risk score of shared IP, the risk score of account creation time, and the risk score of account density with the same IP. It adopts a constraint rule that the weight of the core detection factor is not less than the sum of the weights of all auxiliary factors (W1≥W2+W3+W4) to obtain a comprehensive risk score. Based on the comparison result of the comprehensive risk score with two preset high and low thresholds, it outputs a three-level risk decision: high-risk interception, medium-risk marking and review, and low-risk release.
3. The method according to claim 1, characterized in that, The risk detection events include at least one of the following: user referral relationship binding events, user login verification events, marketing activity participation events, and transaction order placement events; the determination of the first user and the second user to be detected based on event association rules specifically means that, under the referral relationship binding event, the first user is the first object identifier that triggers the binding operation, and the second user is the second object identifier that is being bound; In a login verification event, the first user is the currently logged-in object identifier, and the second user is the suspicious object identifier with risk association within a preset time window; In a marketing campaign participation event, the first user is the primary object identifier for the current operation, and the second user is the secondary object identifier with a preset risk marker. In a transaction order event, the first user is the object identifier of the currently placed order, and the second user is the associated object identifier of the same IP or device within a preset time window.
4. The method according to claim 1, characterized in that, The theoretical optimal value of the number of hash functions k in the Bloom filter, calculated using the formula k=(m / N_max)×ln2, is approximately 7 when m=10×N_max. The corresponding single-element false positive rate p≈(1-e^(-7×N_max / (10×N_max)))^7≈0.82%. In scenarios with a higher tolerance for false positive rates and greater sensitivity to computational overhead, k can also be set to 3 as an alternative configuration. In this case, the single-element false positive rate is approximately 1.74%. This false positive rate only affects false positives in the prediction stage (misjudging non-intersection as possible intersection, thus performing an extra precise calculation), and does not affect the correctness of the detection results—all results that the Bloom filter determines are definitely non-intersections are 100% correct, and there are no false negatives.
5. The method according to claim 1, characterized in that, The risk score F1 for shared devices is calculated as follows: F1 = min(n_intersect / N_max, 1) × 100, where n_intersect is the number of elements in the intersection of the two device fingerprint history sets, and N_max is the maximum number of records in the sliding window. The risk score F2 for shared IP history is calculated as follows: F2 = |IP_A ∩ IP_B| / max(|IP_A ∪ IP_B|, 1) × 100, where IP_A and IP_B are the sets of IP addresses in the two user historical fingerprint sets, respectively. The risk score F3 for account creation timeliness is calculated as follows: F3 = max(0, (1 - t / 7)) × 100, where t is the difference between the creation time of the detected user account and the current time, in days. The risk score F4 for same IP account density is calculated as follows: F4 = min(density / 20, 1). ×100, where density is the total number of accounts historically associated with the current IP address.
6. The method according to claim 1, characterized in that, The weight of the core detection factor is 0.50, the weight of the shared IP historical risk score is 0.25, the weight of the account creation time risk score is 0.125, the weight of the same IP account density risk score is 0.125, and the sum of all weights is 1.0, satisfying the constraint W1≥W2+W3+W4; the first preset scoring threshold is 60 points, and the second preset scoring threshold is 30 points; If the overall risk score is higher than 60, it is considered high risk and the corresponding business operation is blocked. If the overall risk score is between 30 and 60, it is considered medium risk, the operation is allowed and marked for manual review. If the overall risk score is lower than 30, it is considered low risk and the operation is allowed normally.
7. The method according to claim 1, characterized in that, The weight values of each detection factor, the first preset scoring threshold, and the second preset scoring threshold can be dynamically adjusted: at each preset interval, the risk discrimination of each detection factor is calculated based on the fraud sample data labeled within the period, and the weight value of the corresponding factor is adjusted according to the discrimination, with a single weight adjustment not exceeding 0.05; the first preset scoring threshold and the second preset scoring threshold are adjusted based on the balance target of detection rate and false alarm rate.
8. The method according to claim 1, characterized in that, If the extracted user device fingerprint history set is empty, the risk score of the shared device is recorded as 0, and device fingerprints will be continuously collected and accumulated into the set. The salted one-way hash operation adopts the SM3 hash algorithm, and the salt value is a preset global fixed salt value. The original feature data is concatenated with the salt value to calculate the hash value. Only the hashed feature value is stored and the original information is not retained. The maximum number of records in the sliding window is 50, the record validity period is 180 days, and the expiration cleanup task is executed once a day.
9. An electronic device, characterized in that, It includes a processor and a memory, wherein the memory stores a computer program, and the processor executes the computer program to implement the method of any one of claims 1, 3 to 8.
10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the method of any one of claims 1, 3 to 8.
