ಹುಚ್ಚನಾಗದೆ ಚೆಕ್‌ಮಾರ್ಕ್ಸ್‌ಗೆ ನಿಯಮಗಳನ್ನು ಬರೆಯುವುದು ಹೇಗೆ

ಹಲೋ, ಹಬ್ರ್!

ನಮ್ಮ ಕೆಲಸದಲ್ಲಿ, ನಮ್ಮ ಕಂಪನಿಯು ಆಗಾಗ್ಗೆ ವಿವಿಧ ಸ್ಥಿರ ಕೋಡ್ ವಿಶ್ಲೇಷಣೆ ಪರಿಕರಗಳೊಂದಿಗೆ (SAST) ವ್ಯವಹರಿಸುತ್ತದೆ. ಬಾಕ್ಸ್ ಹೊರಗೆ ಅವರು ಎಲ್ಲಾ ಸರಾಸರಿ ಕೆಲಸ. ಸಹಜವಾಗಿ, ಇದು ಎಲ್ಲಾ ಯೋಜನೆ ಮತ್ತು ಅದರಲ್ಲಿ ಬಳಸಿದ ತಂತ್ರಜ್ಞಾನಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ, ಹಾಗೆಯೇ ಈ ತಂತ್ರಜ್ಞಾನಗಳನ್ನು ವಿಶ್ಲೇಷಣೆಯ ನಿಯಮಗಳಿಂದ ಎಷ್ಟು ಚೆನ್ನಾಗಿ ಒಳಗೊಂಡಿದೆ. ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ, SAST ಪರಿಕರವನ್ನು ಆಯ್ಕೆಮಾಡುವಾಗ ಪ್ರಮುಖ ಮಾನದಂಡವೆಂದರೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ನಿಶ್ಚಿತಗಳಿಗೆ ಅದನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡುವ ಸಾಮರ್ಥ್ಯ, ಅವುಗಳೆಂದರೆ, ವಿಶ್ಲೇಷಣೆ ನಿಯಮಗಳನ್ನು ಬರೆಯುವುದು ಮತ್ತು ಬದಲಾಯಿಸುವುದು ಅಥವಾ ಅವುಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಕಸ್ಟಮ್ ಪ್ರಶ್ನೆಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

ನಾವು ಹೆಚ್ಚಾಗಿ ಚೆಕ್‌ಮಾರ್ಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ - ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಮತ್ತು ಶಕ್ತಿಯುತ ಕೋಡ್ ವಿಶ್ಲೇಷಕ. ಈ ಲೇಖನದಲ್ಲಿ ನಾನು ಅದರ ವಿಶ್ಲೇಷಣೆಯ ನಿಯಮಗಳನ್ನು ಬರೆಯುವ ನನ್ನ ಅನುಭವದ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇನೆ.

ಪರಿವಿಡಿ

• ಪ್ರವೇಶ

• ನಿಯಮಗಳ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ಮಾಹಿತಿ

• ಆರಂಭಿಕರಿಗಾಗಿ "ನಿಘಂಟು"

  • ಪಟ್ಟಿಗಳೊಂದಿಗೆ ಕಾರ್ಯಾಚರಣೆಗಳು

  • ಕಂಡುಬರುವ ಎಲ್ಲಾ ವಸ್ತುಗಳು

  • ಹರಿವಿನ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಕಾರ್ಯಗಳು

  • ಫೈಲ್ ಹೆಸರು/ಪಥವನ್ನು ಪಡೆಯಲಾಗುತ್ತಿದೆ

  • ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶ

  • ಇತರ ನಿಯಮಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಬಳಸುವುದು

• ಸಮಸ್ಯೆಗಳ ಪರಿಹಾರ

  • ಲಾಗಿಂಗ್

  • ಲಾಗಿನ್ ಸಮಸ್ಯೆ

• ಬರವಣಿಗೆಯ ನಿಯಮಗಳು

• ತೀರ್ಮಾನಕ್ಕೆ

ಪ್ರವೇಶ

ಮೊದಲಿಗೆ, ಚೆಕ್ಮಾರ್ಕ್ಸ್ಗಾಗಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಬರೆಯುವ ವೈಶಿಷ್ಟ್ಯಗಳ ಬಗ್ಗೆ ರಷ್ಯನ್ ಭಾಷೆಯಲ್ಲಿ ಕೆಲವು ಲೇಖನಗಳಲ್ಲಿ ಒಂದನ್ನು ನಾನು ಶಿಫಾರಸು ಮಾಡಲು ಬಯಸುತ್ತೇನೆ. ಇದನ್ನು 2019 ರ ಕೊನೆಯಲ್ಲಿ ಹಬ್ರೆ ಶೀರ್ಷಿಕೆಯಡಿಯಲ್ಲಿ ಪ್ರಕಟಿಸಲಾಗಿದೆ: "ಹಲೋ, ಚೆಕ್‌ಮಾರ್ಕ್ಸ್!" ಚೆಕ್‌ಮಾರ್ಕ್ಸ್ SAST ಪ್ರಶ್ನೆಯನ್ನು ಬರೆಯುವುದು ಮತ್ತು ತಂಪಾದ ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಹೇಗೆ.

ಕೆಲವು ಪರೀಕ್ಷಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ CxQL (ಚೆಕ್‌ಮಾರ್ಕ್ಸ್ ಕ್ವೆರಿ ಲಾಂಗ್ವೇಜ್) ನಲ್ಲಿ ಮೊದಲ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೇಗೆ ಬರೆಯುವುದು ಎಂಬುದನ್ನು ಇದು ವಿವರವಾಗಿ ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ವಿಶ್ಲೇಷಣೆ ನಿಯಮಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ಮೂಲ ತತ್ವಗಳನ್ನು ತೋರಿಸುತ್ತದೆ.

ಅದರಲ್ಲಿ ವಿವರಿಸಿರುವುದನ್ನು ನಾನು ಪುನರಾವರ್ತಿಸುವುದಿಲ್ಲ, ಆದರೂ ಕೆಲವು ಛೇದಕಗಳು ಇನ್ನೂ ಇರುತ್ತವೆ. ನನ್ನ ಲೇಖನದಲ್ಲಿ ನಾನು ಚೆಕ್‌ಮಾರ್ಕ್ಸ್‌ನೊಂದಿಗಿನ ನನ್ನ ಕೆಲಸದ ಸಮಯದಲ್ಲಿ ನಾನು ಎದುರಿಸಿದ ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಗಳಿಗೆ ಪರಿಹಾರಗಳ ಪಟ್ಟಿಯನ್ನು "ಪಾಕವಿಧಾನಗಳ ಸಂಗ್ರಹ" ವನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ. ಈ ಅನೇಕ ಸಮಸ್ಯೆಗಳ ಮೇಲೆ ನಾನು ನನ್ನ ಮೆದುಳನ್ನು ಕಸಿದುಕೊಳ್ಳಬೇಕಾಗಿತ್ತು. ಕೆಲವೊಮ್ಮೆ ದಾಖಲಾತಿಯಲ್ಲಿ ಸಾಕಷ್ಟು ಮಾಹಿತಿ ಇರಲಿಲ್ಲ, ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಅಗತ್ಯವಿರುವದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸಹ ಕಷ್ಟಕರವಾಗಿತ್ತು. ನನ್ನ ಅನುಭವ ಮತ್ತು ನಿದ್ದೆಯಿಲ್ಲದ ರಾತ್ರಿಗಳು ವ್ಯರ್ಥವಾಗುವುದಿಲ್ಲ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ ಮತ್ತು ಈ "ಕಸ್ಟಮ್ ಪ್ರಶ್ನೆಗಳ ಪಾಕವಿಧಾನಗಳ ಸಂಗ್ರಹ" ನಿಮಗೆ ಕೆಲವು ಗಂಟೆಗಳ ಅಥವಾ ಒಂದೆರಡು ನರ ಕೋಶಗಳನ್ನು ಉಳಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ಪ್ರಾರಂಭಿಸೋಣ!

ನಿಯಮಗಳ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ಮಾಹಿತಿ

ಮೊದಲಿಗೆ, ಮುಂದೆ ಏನಾಗುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ಉತ್ತಮ ತಿಳುವಳಿಕೆಗಾಗಿ ಕೆಲವು ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ನಿಯಮಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನೋಡೋಣ. ಮತ್ತು ದಸ್ತಾವೇಜನ್ನು ಈ ಬಗ್ಗೆ ಏನನ್ನೂ ಹೇಳುವುದಿಲ್ಲ ಅಥವಾ ರಚನೆಯಲ್ಲಿ ತುಂಬಾ ಹರಡಿಕೊಂಡಿದೆ, ಅದು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿಲ್ಲ.

1. ಪ್ರಾರಂಭದಲ್ಲಿ ಆಯ್ಕೆಮಾಡಿದ ಪೂರ್ವನಿಗದಿಯನ್ನು ಅವಲಂಬಿಸಿ ಸ್ಕ್ಯಾನಿಂಗ್ ಸಮಯದಲ್ಲಿ ನಿಯಮಗಳನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ (ಸಕ್ರಿಯ ನಿಯಮಗಳ ಒಂದು ಸೆಟ್). ನೀವು ಅನಿಯಮಿತ ಸಂಖ್ಯೆಯ ಪೂರ್ವನಿಗದಿಗಳನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದು ನಿಮ್ಮ ಪ್ರಕ್ರಿಯೆಯ ನಿಶ್ಚಿತಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ನೀವು ಅವುಗಳನ್ನು ಭಾಷೆಯ ಮೂಲಕ ಗುಂಪು ಮಾಡಬಹುದು ಅಥವಾ ಪ್ರತಿ ಯೋಜನೆಗೆ ಪೂರ್ವನಿಗದಿಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು. ಸಕ್ರಿಯ ನಿಯಮಗಳ ಸಂಖ್ಯೆ ಸ್ಕ್ಯಾನಿಂಗ್‌ನ ವೇಗ ಮತ್ತು ನಿಖರತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ.

   ಚೆಕ್‌ಮಾರ್ಕ್ಸ್ ಇಂಟರ್‌ಫೇಸ್‌ನಲ್ಲಿ ಪೂರ್ವನಿಗದಿಯನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

2. ನಿಯಮಗಳನ್ನು CxAuditor ಎಂಬ ವಿಶೇಷ ಪರಿಕರದಲ್ಲಿ ಸಂಪಾದಿಸಲಾಗಿದೆ. ಇದು ಚೆಕ್‌ಮಾರ್ಕ್ಸ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸುವ ಡೆಸ್ಕ್‌ಟಾಪ್ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ. ಈ ಉಪಕರಣವು ಎರಡು ಕಾರ್ಯಾಚರಣೆಯ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ: ನಿಯಮಗಳನ್ನು ಸಂಪಾದಿಸುವುದು ಮತ್ತು ಈಗಾಗಲೇ ನಿರ್ವಹಿಸಿದ ಸ್ಕ್ಯಾನ್‌ನ ಫಲಿತಾಂಶಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು.

   CxAudit ಇಂಟರ್ಫೇಸ್

3. ಚೆಕ್‌ಮಾರ್ಕ್ಸ್‌ನಲ್ಲಿನ ನಿಯಮಗಳನ್ನು ಭಾಷೆಯಿಂದ ವಿಂಗಡಿಸಲಾಗಿದೆ, ಅಂದರೆ, ಪ್ರತಿ ಭಾಷೆಯು ತನ್ನದೇ ಆದ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದೆ. ಭಾಷೆಯ ಹೊರತಾಗಿಯೂ ಅನ್ವಯಿಸುವ ಕೆಲವು ಸಾಮಾನ್ಯ ನಿಯಮಗಳಿವೆ, ಇವು ಮೂಲಭೂತ ಪ್ರಶ್ನೆಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತವೆ. ಬಹುಪಾಲು, ಮೂಲಭೂತ ಪ್ರಶ್ನೆಗಳು ಇತರ ನಿಯಮಗಳನ್ನು ಬಳಸುವ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

   ಭಾಷೆಯಿಂದ ನಿಯಮಗಳನ್ನು ವಿಭಜಿಸುವುದು

4. ನಿಯಮಗಳು "ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ" ಮತ್ತು "ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗದ" (ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿಲ್ಲ). ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ ಸರಿಯಾದ ಹೆಸರು ಅಲ್ಲ, ಆದರೆ ಅದು ಏನು. ಬಾಟಮ್ ಲೈನ್ ಏನೆಂದರೆ, "ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ" ನಿಯಮಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಫಲಿತಾಂಶವನ್ನು UI ನಲ್ಲಿನ ಸ್ಕ್ಯಾನ್ ಫಲಿತಾಂಶಗಳಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ ಮತ್ತು "ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗದ" ನಿಯಮಗಳು ಇತರ ವಿನಂತಿಗಳಲ್ಲಿ ಅವುಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಬಳಸಲು ಮಾತ್ರ ಅಗತ್ಯವಿದೆ (ಮೂಲತಃ, ಕೇವಲ ಒಂದು ಕಾರ್ಯ).

   ರಚಿಸುವಾಗ ನಿಯಮ ಪ್ರಕಾರವನ್ನು ನಿರ್ಧರಿಸುವುದು

5. ನೀವು ಹೊಸ ನಿಯಮಗಳನ್ನು ರಚಿಸಬಹುದು ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವವುಗಳನ್ನು ಪೂರಕ / ಪುನಃ ಬರೆಯಬಹುದು. ನಿಯಮವನ್ನು ಪುನಃ ಬರೆಯಲು, ನೀವು ಅದನ್ನು ಮರದಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬೇಕು, ಬಲ ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಡ್ರಾಪ್-ಡೌನ್ ಮೆನುವಿನಿಂದ "ಅತಿಕ್ರಮಣ" ಆಯ್ಕೆಮಾಡಿ. ಹೊಸ ನಿಯಮಗಳನ್ನು ಆರಂಭದಲ್ಲಿ ಪೂರ್ವನಿಗದಿಗಳಲ್ಲಿ ಸೇರಿಸಲಾಗಿಲ್ಲ ಮತ್ತು ಸಕ್ರಿಯವಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ಇಲ್ಲಿ ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಅವುಗಳನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಲು ನೀವು ಉಪಕರಣದಲ್ಲಿನ "ಪ್ರಿಸೆಟ್ ಮ್ಯಾನೇಜರ್" ಮೆನುವಿನಲ್ಲಿ ಅವುಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು. ಪುನಃ ಬರೆಯಲಾದ ನಿಯಮಗಳು ಅವುಗಳ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತವೆ, ಅಂದರೆ, ನಿಯಮವು ಸಕ್ರಿಯವಾಗಿದ್ದರೆ, ಅದು ಹಾಗೆಯೇ ಉಳಿಯುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣವೇ ಅನ್ವಯಿಸುತ್ತದೆ.

   ಪ್ರೀಸೆಟ್ ಮ್ಯಾನೇಜರ್ ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ ಹೊಸ ನಿಯಮದ ಉದಾಹರಣೆ

6. ಮರಣದಂಡನೆಯ ಸಮಯದಲ್ಲಿ, ವಿನಂತಿಗಳ "ಮರ" ವನ್ನು ನಿರ್ಮಿಸಲಾಗಿದೆ, ಅದು ಏನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವ ನಿಯಮಗಳನ್ನು ಮೊದಲು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಬಳಸುವವರು ಎರಡನೆಯದು. ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ, ಆದ್ದರಿಂದ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನಿಯಮದ ಫಲಿತಾಂಶಗಳನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಾದರೆ, ಹಾಗೆ ಮಾಡುವುದು ಉತ್ತಮ, ಇದು ಸ್ಕ್ಯಾನಿಂಗ್ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

7. ನಿಯಮಗಳನ್ನು ವಿವಿಧ ಹಂತಗಳಲ್ಲಿ ಅನ್ವಯಿಸಬಹುದು:

• ಸಂಪೂರ್ಣ ಸಿಸ್ಟಮ್‌ಗಾಗಿ - ಯಾವುದೇ ಯೋಜನೆಯ ಯಾವುದೇ ಸ್ಕ್ಯಾನಿಂಗ್‌ಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ

• ತಂಡದ ಮಟ್ಟದಲ್ಲಿ (ತಂಡ) - ಆಯ್ಕೆಮಾಡಿದ ತಂಡದಲ್ಲಿನ ಯೋಜನೆಗಳನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡಲು ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ.

• ಯೋಜನೆಯ ಮಟ್ಟದಲ್ಲಿ - ನಿರ್ದಿಷ್ಟ ಯೋಜನೆಯಲ್ಲಿ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ

  ನಿಯಮವನ್ನು ಅನ್ವಯಿಸುವ ಮಟ್ಟವನ್ನು ನಿರ್ಧರಿಸುವುದು

ಆರಂಭಿಕರಿಗಾಗಿ "ನಿಘಂಟು"

ಮತ್ತು ನನಗೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಉಂಟುಮಾಡಿದ ಕೆಲವು ವಿಷಯಗಳೊಂದಿಗೆ ನಾನು ಪ್ರಾರಂಭಿಸುತ್ತೇನೆ ಮತ್ತು ಜೀವನವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸರಳಗೊಳಿಸುವ ಹಲವಾರು ತಂತ್ರಗಳನ್ನು ಸಹ ನಾನು ತೋರಿಸುತ್ತೇನೆ.

ಪಟ್ಟಿಗಳೊಂದಿಗೆ ಕಾರ್ಯಾಚರಣೆಗಳು

- вычитание одного из другого (list2 - list1)
* пересечение списков (list1 * list2)
+ сложение списков (list1 + list2)

& (логическое И) - объединяет списки по совпадению (list1 & list2), аналогично пересечению (list1 * list2)
| (логическое ИЛИ) - объединяет списки по широкому поиску (list1 | list2)

Со списками не работает:  ^  &&  ||  %  / 

ಕಂಡುಬರುವ ಎಲ್ಲಾ ವಸ್ತುಗಳು

ಸ್ಕ್ಯಾನ್ ಮಾಡಿದ ಭಾಷೆಯೊಳಗೆ, ಚೆಕ್‌ಮಾರ್ಕ್ಸ್ ಗುರುತಿಸಿರುವ ಎಲ್ಲಾ ಅಂಶಗಳ ಪಟ್ಟಿಯನ್ನು ನೀವು ಪಡೆಯಬಹುದು (ಸ್ಟ್ರಿಂಗ್‌ಗಳು, ಕಾರ್ಯಗಳು, ತರಗತಿಗಳು, ವಿಧಾನಗಳು, ಇತ್ಯಾದಿ.). ಈ ಮೂಲಕ ಪ್ರವೇಶಿಸಬಹುದಾದ ವಸ್ತುಗಳ ಕೆಲವು ಸ್ಥಳವಾಗಿದೆ All. ಅಂದರೆ, ನಿರ್ದಿಷ್ಟ ಹೆಸರಿನೊಂದಿಗೆ ವಸ್ತುವನ್ನು ಹುಡುಕಲು searchMe, ನೀವು ಹುಡುಕಬಹುದು, ಉದಾಹರಣೆಗೆ, ಎಲ್ಲಾ ಕಂಡುಬರುವ ವಸ್ತುಗಳಾದ್ಯಂತ ಹೆಸರಿನ ಮೂಲಕ:

// Такой запрос выдаст все элементы
result = All;

// Такой запрос выдаст все элементы, в имени которых присутствует “searchMe“
result = All.FindByName("searchMe");

ಆದರೆ, ಕೆಲವು ಕಾರಣಗಳಿಂದ ಸ್ಕ್ಯಾನ್‌ನಲ್ಲಿ ಸೇರಿಸಲಾಗಿಲ್ಲ ಎಂದು ನೀವು ಇನ್ನೊಂದು ಭಾಷೆಯಲ್ಲಿ ಹುಡುಕಬೇಕಾದರೆ (ಉದಾಹರಣೆಗೆ, ಆಂಡ್ರಾಯ್ಡ್ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಗ್ರೂವಿ), ನೀವು ವೇರಿಯೇಬಲ್ ಮೂಲಕ ನಮ್ಮ ವಸ್ತು ಜಾಗವನ್ನು ವಿಸ್ತರಿಸಬಹುದು:

result = AllMembers.All.FindByName("searchMe");

ಹರಿವಿನ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಕಾರ್ಯಗಳು

ಈ ಕಾರ್ಯಗಳನ್ನು ಹಲವು ನಿಯಮಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅವುಗಳ ಅರ್ಥದ ಸ್ವಲ್ಪ ಚೀಟ್ ಶೀಟ್ ಇಲ್ಲಿದೆ:

// Какие данные second влияют на first.
// Другими словами - ТО (second) что влияет на  МЕНЯ (first).
result = first.DataInfluencedBy(second);

// Какие данные first влияют на second.
// Другими словами - Я (first) влияю на ТО (second).
result = first.DataInfluencingOn(second);

ಫೈಲ್ ಹೆಸರು/ಪಥವನ್ನು ಪಡೆಯಲಾಗುತ್ತಿದೆ

ಪ್ರಶ್ನೆಯ ಫಲಿತಾಂಶಗಳಿಂದ ಪಡೆಯಬಹುದಾದ ಹಲವಾರು ಗುಣಲಕ್ಷಣಗಳಿವೆ (ಪ್ರವೇಶ ಕಂಡುಬಂದ ಫೈಲ್‌ನ ಹೆಸರು, ಸ್ಟ್ರಿಂಗ್, ಇತ್ಯಾದಿ), ಆದರೆ ದಸ್ತಾವೇಜನ್ನು ಅವುಗಳನ್ನು ಹೇಗೆ ಪಡೆಯುವುದು ಮತ್ತು ಬಳಸುವುದು ಎಂದು ಹೇಳುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ, ಇದನ್ನು ಮಾಡಲು, ನೀವು ಲೈನ್‌ಪ್ರಾಗ್ಮಾ ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ನಮಗೆ ಅಗತ್ಯವಿರುವ ವಸ್ತುಗಳು ಅದರೊಳಗೆ ಇರುತ್ತವೆ:

// Для примера найдем все методы
CxList methods = Find_Methods();

// В методах найдем по имени метод scope
CxList scope = methods.FindByName("scope");

// Таким образом можо получить путь к файлу
string current_filename = scope.GetFirstGraph().LinePragma.FileName;

// А вот таким - строку, где нашлось срабатывание
int current_line = scope.GetFirstGraph().LinePragma.Line;

// Эти параметры можно использовать по разному
// Например получить все объекты в файле
CxList inFile = All.FindByFileName(current_filename);

// Или найти что происходит в конкретной строке
CxList inLine = inFile.FindByPosition(current_line);

ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ FileName ನಾವು ವಿಧಾನವನ್ನು ಬಳಸಿರುವುದರಿಂದ ಫೈಲ್‌ಗೆ ವಾಸ್ತವವಾಗಿ ಮಾರ್ಗವನ್ನು ಒಳಗೊಂಡಿದೆ GetFirstGraph.

ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶ

CxQL ಒಳಗೆ ವಿಶೇಷ ವೇರಿಯಬಲ್ ಇದೆ result, ಇದು ನಿಮ್ಮ ಲಿಖಿತ ನಿಯಮವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಫಲಿತಾಂಶವನ್ನು ನೀಡುತ್ತದೆ. ಇದನ್ನು ತಕ್ಷಣವೇ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನೀವು ಮಧ್ಯಂತರ ಫಲಿತಾಂಶಗಳನ್ನು ಅದರಲ್ಲಿ ಬರೆಯಬಹುದು, ನೀವು ಕೆಲಸ ಮಾಡುವಾಗ ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು ಮತ್ತು ಸಂಸ್ಕರಿಸಬಹುದು. ಆದರೆ, ಈ ವೇರಿಯಬಲ್‌ಗೆ ಯಾವುದೇ ನಿಯೋಜನೆ ಇಲ್ಲದಿದ್ದರೆ ಅಥವಾ ನಿಯಮದ ಒಳಗೆ ಕಾರ್ಯ return- ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶವು ಯಾವಾಗಲೂ ಶೂನ್ಯವಾಗಿರುತ್ತದೆ.

ಈ ಕೆಳಗಿನ ಪ್ರಶ್ನೆಯು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಪರಿಣಾಮವಾಗಿ ನಮಗೆ ಏನನ್ನೂ ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ ಮತ್ತು ಯಾವಾಗಲೂ ಖಾಲಿಯಾಗಿರುತ್ತದೆ:

// Находим элементы foo
CxList libraries = All.FindByName("foo");

ಆದರೆ, ಮ್ಯಾಜಿಕ್ ವೇರಿಯಬಲ್ ಫಲಿತಾಂಶಕ್ಕೆ ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶವನ್ನು ನಿಗದಿಪಡಿಸಿದ ನಂತರ, ಈ ಕರೆ ನಮಗೆ ಏನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ:

// Находим элементы foo
CxList libraries = All.FindByName("foo");

// Выводим, как результат выполнения правила
result = libraries

// Или еще короче
result = All.FindByName("foo");

ಇತರ ನಿಯಮಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಬಳಸುವುದು

ಚೆಕ್‌ಮಾರ್ಕ್ಸ್‌ನಲ್ಲಿನ ನಿಯಮಗಳನ್ನು ನಿಯಮಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿನ ಕಾರ್ಯಗಳಿಗೆ ಸದೃಶವೆಂದು ಕರೆಯಬಹುದು. ನಿಯಮವನ್ನು ಬರೆಯುವಾಗ, ನೀವು ಇತರ ಪ್ರಶ್ನೆಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಚೆನ್ನಾಗಿ ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಪ್ರತಿ ಬಾರಿ ಕೋಡ್‌ನಲ್ಲಿ ಎಲ್ಲಾ ವಿಧಾನ ಕರೆಗಳನ್ನು ಹುಡುಕುವ ಅಗತ್ಯವಿಲ್ಲ, ಬಯಸಿದ ನಿಯಮವನ್ನು ಕರೆ ಮಾಡಿ:

// Получаем результат выполнения другого правила
CxList methods = Find_Methods();

// Ищем внутри метод foo. 
// Второй параметр false означает, что ищем без чувствительности к регистру
result = methods.FindByShortName("foo", false);

ಈ ವಿಧಾನವು ಕೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ನಿಯಮದ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಸಮಸ್ಯೆಗಳ ಪರಿಹಾರ

ಲಾಗಿಂಗ್

ಉಪಕರಣದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಕೆಲವೊಮ್ಮೆ ಬಯಸಿದ ಪ್ರಶ್ನೆಯನ್ನು ತಕ್ಷಣವೇ ಬರೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ ಮತ್ತು ನೀವು ವಿಭಿನ್ನ ಆಯ್ಕೆಗಳನ್ನು ಪ್ರಯತ್ನಿಸುತ್ತಾ ಪ್ರಯೋಗ ಮಾಡಬೇಕು. ಅಂತಹ ಸಂದರ್ಭದಲ್ಲಿ, ಉಪಕರಣವು ಲಾಗಿಂಗ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಕರೆಯಲಾಗುತ್ತದೆ:

// Находим что-то
CxList toLog = All.FindByShortName("log");

// Формируем строку и отправляем в лог
cxLog.WriteDebugMessage (“number of DOM elements =” + All.Count);

ಆದರೆ ಈ ವಿಧಾನವು ಇನ್ಪುಟ್ ಆಗಿ ಮಾತ್ರ ಸ್ವೀಕರಿಸುತ್ತದೆ ಎಂದು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ ಸ್ಟ್ರಿಂಗ್, ಆದ್ದರಿಂದ ಮೊದಲ ಕಾರ್ಯಾಚರಣೆಯ ಪರಿಣಾಮವಾಗಿ ಕಂಡುಬರುವ ಅಂಶಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಡೀಬಗ್ ಮಾಡಲು ಬಳಸಲಾಗುವ ಎರಡನೇ ಆಯ್ಕೆಯು ಕಾಲಕಾಲಕ್ಕೆ ಮ್ಯಾಜಿಕ್ ವೇರಿಯಬಲ್‌ಗೆ ನಿಯೋಜಿಸುವುದು result ಪ್ರಶ್ನೆಯ ಫಲಿತಾಂಶ ಮತ್ತು ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡಿ. ಈ ವಿಧಾನವು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿಲ್ಲ; ನಂತರ ಕೋಡ್‌ನಲ್ಲಿ ಇದರೊಂದಿಗೆ ಯಾವುದೇ ಅತಿಕ್ರಮಣಗಳು ಅಥವಾ ಕಾರ್ಯಾಚರಣೆಗಳಿಲ್ಲ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು result ಅಥವಾ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಕಾಮೆಂಟ್ ಮಾಡಿ. ಅಥವಾ ನೀವು, ನನ್ನಂತೆಯೇ, ಸಿದ್ಧ ನಿಯಮದಿಂದ ಅಂತಹ ಹಲವಾರು ಕರೆಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಮರೆತುಬಿಡಬಹುದು ಮತ್ತು ಏನೂ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ ಎಂದು ಆಶ್ಚರ್ಯಪಡಬಹುದು.

ವಿಧಾನವನ್ನು ಕರೆಯುವುದು ಹೆಚ್ಚು ಅನುಕೂಲಕರ ಮಾರ್ಗವಾಗಿದೆ return ಅಗತ್ಯವಿರುವ ನಿಯತಾಂಕದೊಂದಿಗೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಯಮದ ಮರಣದಂಡನೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ನಾವು ಬರೆದದ್ದರ ಪರಿಣಾಮವಾಗಿ ಏನಾಯಿತು ಎಂಬುದನ್ನು ನಾವು ನೋಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ:

// Находим что-то
CxList toLog = All.FindByShortName("log");

// Выводим результат выполнения
return toLog

//Все, что написано дальше не будет выполнено
result = All.DataInfluencedBy(toLog)

ಲಾಗಿನ್ ಸಮಸ್ಯೆ

ನೀವು CxAudit ಉಪಕರಣವನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗದ ಸಂದರ್ಭಗಳಿವೆ (ನಿಯಮಗಳನ್ನು ಬರೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ). ಇದಕ್ಕೆ ಕ್ರ್ಯಾಶ್‌ಗಳು, ಹಠಾತ್ ವಿಂಡೋಸ್ ನವೀಕರಣಗಳು, BSOD ಮತ್ತು ನಮ್ಮ ನಿಯಂತ್ರಣಕ್ಕೆ ಮೀರಿದ ಇತರ ಅನಿರೀಕ್ಷಿತ ಸಂದರ್ಭಗಳು ಸೇರಿದಂತೆ ಹಲವು ಕಾರಣಗಳಿರಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕೆಲವೊಮ್ಮೆ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಅಪೂರ್ಣ ಸೆಷನ್ ಇರುತ್ತದೆ, ಅದು ನಿಮ್ಮನ್ನು ಮತ್ತೆ ಲಾಗ್ ಇನ್ ಮಾಡುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಅದನ್ನು ಸರಿಪಡಿಸಲು, ನೀವು ಹಲವಾರು ಪ್ರಶ್ನೆಗಳನ್ನು ಚಲಾಯಿಸಬೇಕು:

8.6 ಕ್ಕಿಂತ ಮೊದಲು ಚೆಕ್‌ಮಾರ್ಕ್‌ಗಾಗಿ:

// Проверяем, что есть залогиненые пользователи, выполнив запрос в БД
SELECT COUNT(*) FROM [CxDB].[dbo].LoggedinUser WHERE [ClientType] = 6;
 
// Если что-то есть, а на самом деле даже если и нет, попробовать выполнить запрос
DELETE FROM [CxDB].[dbo].LoggedinUser WHERE [ClientType] = 6;

8.6 ರ ನಂತರ ಚೆಕ್‌ಮಾರ್ಕ್‌ಗಾಗಿ:

// Проверяем, что есть залогиненые пользователи, выполнив запрос в БД
SELECT COUNT(*) FROM LoggedinUser WHERE (ClientType = 'Audit');
 
// Если что-то есть, а на самом деле даже если и нет, попробовать выполнить запрос
DELETE FROM [CxDB].[dbo].LoggedinUser WHERE (ClientType = 'Audit');

ಬರವಣಿಗೆಯ ನಿಯಮಗಳು

ಈಗ ನಾವು ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಭಾಗಕ್ಕೆ ಹೋಗುತ್ತೇವೆ. ನೀವು CxQL ನಲ್ಲಿ ನಿಯಮಗಳನ್ನು ಬರೆಯಲು ಪ್ರಾರಂಭಿಸಿದಾಗ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಕೊರತೆಯಿರುವುದು ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರಶ್ನೆಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವಿವರಿಸುವ ಕೆಲವು ಜೀವಂತ ಉದಾಹರಣೆಗಳಂತಹ ಹೆಚ್ಚಿನ ದಾಖಲಾತಿಗಳಲ್ಲ.

ಪ್ರಶ್ನೆ ಭಾಷೆಗೆ ಧುಮುಕಲು ಪ್ರಾರಂಭಿಸುವವರಿಗೆ ಜೀವನವನ್ನು ಸ್ವಲ್ಪ ಸುಲಭಗೊಳಿಸಲು ನಾನು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ ಮತ್ತು ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಕಸ್ಟಮ್ ಪ್ರಶ್ನೆಗಳನ್ನು ಬಳಸುವ ಹಲವಾರು ಉದಾಹರಣೆಗಳನ್ನು ನೀಡುತ್ತೇನೆ. ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಸಾಕಷ್ಟು ಸಾಮಾನ್ಯವಾಗಿದೆ ಮತ್ತು ನಿಮ್ಮ ಕಂಪನಿಯಲ್ಲಿ ಪ್ರಾಯೋಗಿಕವಾಗಿ ಬದಲಾವಣೆಗಳಿಲ್ಲದೆ ಬಳಸಬಹುದು, ಇತರವುಗಳು ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿವೆ, ಆದರೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ನಿಶ್ಚಿತಗಳಿಗೆ ಸರಿಹೊಂದುವಂತೆ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಅವುಗಳನ್ನು ಬಳಸಬಹುದು.

ಆದ್ದರಿಂದ, ನಾವು ಹೆಚ್ಚಾಗಿ ಎದುರಿಸುವ ಸಮಸ್ಯೆಗಳು ಇಲ್ಲಿವೆ:

ಕಾರ್ಯ: ನಿಯಮವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಫಲಿತಾಂಶಗಳಲ್ಲಿ ಹಲವಾರು ಹರಿವುಗಳಿವೆ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಒಂದು ಇನ್ನೊಂದರ ಗೂಡು, ನೀವು ಅವುಗಳಲ್ಲಿ ಒಂದನ್ನು ಬಿಡಬೇಕು.

ಪರಿಹಾರ: ವಾಸ್ತವವಾಗಿ, ಕೆಲವೊಮ್ಮೆ ಚೆಕ್‌ಮಾರ್ಕ್ಸ್ ಅತಿಕ್ರಮಿಸಬಹುದಾದ ಹಲವಾರು ಡೇಟಾ ಹರಿವುಗಳನ್ನು ತೋರಿಸುತ್ತದೆ ಮತ್ತು ಇತರರ ಸಂಕ್ಷಿಪ್ತ ಆವೃತ್ತಿಯಾಗಿದೆ. ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ ವಿಶೇಷ ವಿಧಾನವಿದೆ ಹರಿವನ್ನು ಕಡಿಮೆ ಮಾಡಿ. ನಿಯತಾಂಕವನ್ನು ಅವಲಂಬಿಸಿ, ಇದು ಕಡಿಮೆ ಅಥವಾ ದೀರ್ಘವಾದ ಹರಿವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ:

// Оставить только длинные Flow
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceSmallFlow);

// Оставить только короткие Flow
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceBigFlow);

ಕಾರ್ಯ: ಉಪಕರಣವು ಪ್ರತಿಕ್ರಿಯಿಸುವ ಸೂಕ್ಷ್ಮ ಡೇಟಾದ ಪಟ್ಟಿಯನ್ನು ವಿಸ್ತರಿಸಿ

ಪರಿಹಾರ: ಚೆಕ್‌ಮಾರ್ಕ್ಸ್ ಮೂಲಭೂತ ನಿಯಮಗಳನ್ನು ಹೊಂದಿದೆ, ಅದರ ಫಲಿತಾಂಶಗಳನ್ನು ಅನೇಕ ಇತರ ಪ್ರಶ್ನೆಗಳಿಂದ ಬಳಸಲಾಗುತ್ತದೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ನಿರ್ದಿಷ್ಟವಾದ ಡೇಟಾದೊಂದಿಗೆ ಈ ಕೆಲವು ನಿಯಮಗಳನ್ನು ಪೂರೈಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಸ್ಕ್ಯಾನ್ ಫಲಿತಾಂಶಗಳನ್ನು ನೀವು ತಕ್ಷಣವೇ ಸುಧಾರಿಸಬಹುದು. ನೀವು ಪ್ರಾರಂಭಿಸಲು ಒಂದು ಉದಾಹರಣೆ ನಿಯಮವನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ:

ಸಾಮಾನ್ಯ_ಗೌಪ್ಯತೆ_ಉಲ್ಲಂಘನೆ_ಪಟ್ಟಿ

ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಬಳಸಲಾಗುವ ಹಲವಾರು ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಸೇರಿಸೋಣ:

// Получаем результат выполнения базового правила
result = base.General_privacy_violation_list();

// Ищем элементы, которые попадают под простые регулярные выражения. Можно дополнить характерными для вас паттернами.
CxList personalList = All.FindByShortNames(new List<string> {
	"*securityToken*", "*sessionId*"}, false);

// Добавляем к конечному результату
result.Add(personalList);

ಕಾರ್ಯ: ಪಾಸ್ವರ್ಡ್ಗಳೊಂದಿಗೆ ವೇರಿಯಬಲ್ಗಳ ಪಟ್ಟಿಯನ್ನು ವಿಸ್ತರಿಸಿ

ಪರಿಹಾರ: ಕೋಡ್‌ನಲ್ಲಿ ಪಾಸ್‌ವರ್ಡ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಕಂಪನಿಯಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳ ಪಟ್ಟಿಯನ್ನು ಸೇರಿಸಲು ಮೂಲಭೂತ ನಿಯಮಕ್ಕೆ ತಕ್ಷಣ ಗಮನ ಹರಿಸಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.

Password_privacy_violation_list

CxList allStrings = All.FindByType("String"); 
allStrings.Add(All.FindByType(typeof(StringLiteral))); 
allStrings.Add(Find_UnknownReference());
allStrings.Add(All.FindByType(typeof (Declarator)));
allStrings.Add(All.FindByType(typeof (MemberAccess)));
allStrings.Add(All.FindByType(typeof(EnumMemberDecl))); 
allStrings.Add(Find_Methods().FindByShortName("get*"));

// Дополняем дефолтный список переменных
List < string > pswdIncludeList = new List<string>{"*password*", "*psw", "psw*", "pwd*", "*pwd", "*authKey*", "pass*", "cipher*", "*cipher", "pass", "adgangskode", "benutzerkennwort", "chiffre", "clave", "codewort", "contrasena", "contrasenya", "geheimcode", "geslo", "heslo", "jelszo", "kennwort", "losenord", "losung", "losungswort", "lozinka", "modpas", "motdepasse", "parol", "parola", "parole", "pasahitza", "pasfhocal", "passe", "passord", "passwort", "pasvorto", "paswoord", "salasana", "schluessel", "schluesselwort", "senha", "sifre", "wachtwoord", "wagwoord", "watchword", "zugangswort", "PAROLACHIAVE", "PAROLA CHIAVE", "PAROLECHIAVI", "PAROLE CHIAVI", "paroladordine", "verschluesselt", "sisma",
                "pincode",
								"pin"};
								
List < string > pswdExcludeList = new List<string>{"*pass", "*passable*", "*passage*", "*passenger*", "*passer*", "*passing*", "*passion*", "*passive*", "*passover*", "*passport*", "*passed*", "*compass*", "*bypass*", "pass-through", "passthru", "passthrough", "passbytes", "passcount", "passratio"};

CxList tempResult = allStrings.FindByShortNames(pswdIncludeList, false);
CxList toRemove = tempResult.FindByShortNames(pswdExcludeList, false);
tempResult -= toRemove;
tempResult.Add(allStrings.FindByShortName("pass", false));

foreach (CxList r in tempResult)
{
	CSharpGraph g = r.data.GetByIndex(0) as CSharpGraph;
	if(g != null && g.ShortName != null && g.ShortName.Length < 50)
	{
		result.Add(r);
	}
}

ಕಾರ್ಯ: ಚೆಕ್‌ಮಾರ್ಕ್‌ನಿಂದ ಬೆಂಬಲಿಸದ ಬಳಸಿದ ಚೌಕಟ್ಟುಗಳನ್ನು ಸೇರಿಸಿ

ಪರಿಹಾರ: ಚೆಕ್‌ಮಾರ್ಕ್ಸ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಪ್ರಶ್ನೆಗಳನ್ನು ಭಾಷೆಯಿಂದ ವಿಂಗಡಿಸಲಾಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಪ್ರತಿ ಭಾಷೆಗೆ ನಿಯಮಗಳನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ. ಅಂತಹ ನಿಯಮಗಳ ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

ಪ್ರಮಾಣಿತ ಕಾರ್ಯಚಟುವಟಿಕೆಯನ್ನು ಪೂರಕವಾಗಿ ಅಥವಾ ಬದಲಿಸುವ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಬಳಸಿದರೆ, ಅವುಗಳನ್ನು ಸುಲಭವಾಗಿ ಮೂಲಭೂತ ನಿಯಮಕ್ಕೆ ಸೇರಿಸಬಹುದು. ನಂತರ ಅದನ್ನು ಬಳಸುವ ಪ್ರತಿಯೊಬ್ಬರೂ ತಕ್ಷಣ ಹೊಸ ಪರಿಚಯಗಳ ಬಗ್ಗೆ ಕಲಿಯುತ್ತಾರೆ. ಉದಾಹರಣೆಗೆ, ಆಂಡ್ರಾಯ್ಡ್‌ನಲ್ಲಿ ಲಾಗಿಂಗ್ ಮಾಡಲು ಲೈಬ್ರರಿಗಳು ಟಿಂಬರ್ ಮತ್ತು ಲಾಗ್ಗಿ. ಮೂಲ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ, ಸಿಸ್ಟಮ್ ಅಲ್ಲದ ಕರೆಗಳನ್ನು ಗುರುತಿಸಲು ಯಾವುದೇ ನಿಯಮಗಳಿಲ್ಲ, ಆದ್ದರಿಂದ ಪಾಸ್‌ವರ್ಡ್ ಅಥವಾ ಸೆಷನ್ ಐಡೆಂಟಿಫೈಯರ್ ಲಾಗ್‌ಗೆ ಬಂದರೆ, ಅದರ ಬಗ್ಗೆ ನಮಗೆ ತಿಳಿದಿರುವುದಿಲ್ಲ. ಚೆಕ್ಮಾರ್ಕ್ಸ್ ನಿಯಮಗಳಿಗೆ ಅಂತಹ ವಿಧಾನಗಳ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ.

ಲಾಗಿಂಗ್ ಮಾಡಲು ಟಿಂಬರ್ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುವ ಪರೀಕ್ಷಾ ಕೋಡ್ ಉದಾಹರಣೆ:

package com.death.timberdemo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import timber.log.Timber;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = MainActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Timber.e("Error Message");
        Timber.d("Debug Message");

        Timber.tag("Some Different tag").e("And error message");
    }
}

ಮತ್ತು ಚೆಕ್‌ಮಾರ್ಕ್‌ಗಾಗಿ ವಿನಂತಿಯ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ, ಇದು ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ಡೇಟಾಗೆ ನಿರ್ಗಮನ ಬಿಂದುವಾಗಿ ಮರದ ವಿಧಾನಗಳನ್ನು ಕರೆಯುವ ವ್ಯಾಖ್ಯಾನವನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ:

FindAndroidOutputs

// Получаем результат выполнения базового правила
result = base.Find_Android_Outputs();

// Дополняем вызовами, которые приходят из библиотеки Timber
CxList timber = All.FindByExactMemberAccess("Timber.*") +
    All.FindByShortName("Timber").GetMembersOfTarget();

// Добавляем к конечному результату
result.Add(timber);

ಮತ್ತು ನೀವು ನೆರೆಯ ನಿಯಮಕ್ಕೆ ಕೂಡ ಸೇರಿಸಬಹುದು, ಆದರೆ ಇದು ನೇರವಾಗಿ ಆಂಡ್ರಾಯ್ಡ್‌ನಲ್ಲಿ ಲಾಗಿಂಗ್‌ಗೆ ಸಂಬಂಧಿಸಿದೆ:

FindAndroidLog_Outputs

// Получаем результат выполнения базового правила
result = base.Find_Android_Log_Outputs();

// Дополняем вызовами, которые приходят из библиотеки Timber
result.Add(
  All.FindByExactMemberAccess("Timber.*") +
  All.FindByShortName("Timber").GetMembersOfTarget()
);

ಅಲ್ಲದೆ, Android ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಬಳಸಿದರೆ ಕಾರ್ಯ ನಿರ್ವಾಹಕ ಅಸಮಕಾಲಿಕ ಕೆಲಸಕ್ಕಾಗಿ, ಕಾರ್ಯದಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುವ ವಿಧಾನವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಚೆಕ್‌ಮಾರ್ಕ್ಸ್‌ಗೆ ಹೆಚ್ಚುವರಿಯಾಗಿ ತಿಳಿಸುವುದು ಒಳ್ಳೆಯದು getInputData:

FindAndroidRead

// Получаем результат выполнения базового правила
result = base.Find_Android_Read();

// Дополняем вызовом функции getInputData, которая используется в WorkManager
CxList getInputData = All.FindByShortName("getInputData");

// Добавляем к конечному результату
result.Add(getInputData.GetMembersOfTarget());

ಕಾರ್ಯ: iOS ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗಾಗಿ plist ನಲ್ಲಿ ಸೂಕ್ಷ್ಮವಾದ ಡೇಟಾವನ್ನು ಹುಡುಕಲಾಗುತ್ತಿದೆ

ಪರಿಹಾರ: ವಿವಿಧ ವೇರಿಯಬಲ್‌ಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು iOS ಸಾಮಾನ್ಯವಾಗಿ .plist ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ವಿಶೇಷ ಫೈಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಈ ಫೈಲ್‌ಗಳಲ್ಲಿ ಪಾಸ್‌ವರ್ಡ್‌ಗಳು, ಟೋಕನ್‌ಗಳು, ಕೀಗಳು ಮತ್ತು ಇತರ ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವುದನ್ನು ಶಿಫಾರಸು ಮಾಡುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಅವುಗಳನ್ನು ಯಾವುದೇ ಸಮಸ್ಯೆಗಳಿಲ್ಲದೆ ಸಾಧನದಿಂದ ಹೊರತೆಗೆಯಬಹುದು.

ಪ್ಲಿಸ್ಟ್ ಫೈಲ್‌ಗಳು ಬರಿಗಣ್ಣಿಗೆ ಸ್ಪಷ್ಟವಾಗಿಲ್ಲದ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿವೆ, ಆದರೆ ಚೆಕ್‌ಮಾರ್ಕ್‌ಗೆ ಮುಖ್ಯವಾಗಿದೆ. ನಮಗೆ ಅಗತ್ಯವಿರುವ ಡೇಟಾವನ್ನು ಹುಡುಕುವ ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್‌ಗಳು ಅಥವಾ ಟೋಕನ್‌ಗಳನ್ನು ಎಲ್ಲೋ ನಮೂದಿಸಿದ್ದರೆ ನಮಗೆ ತಿಳಿಸುವ ನಿಯಮವನ್ನು ಬರೆಯೋಣ.

ಬ್ಯಾಕೆಂಡ್ ಸೇವೆಯೊಂದಿಗೆ ಸಂವಹನಕ್ಕಾಗಿ ಟೋಕನ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಅಂತಹ ಫೈಲ್‌ನ ಉದಾಹರಣೆ:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>DeviceDictionary</key>
	<dict>
		<key>phone</key>
		<string>iPhone 6s</string>
	</dict>
	<key>privatekey</key>
	<string>MIICXAIBAAKBgQCqGKukO1De7zhZj6+</string>
</dict>
</plist>

ಮತ್ತು ಚೆಕ್‌ಮಾರ್ಕ್‌ಗೆ ಒಂದು ನಿಯಮ, ಇದು ಬರೆಯುವಾಗ ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಹಲವಾರು ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಹೊಂದಿದೆ:

// Используем результат выполнения правила по поиску файлов plist, чтобы уменьшить время работы правила и 
CxList plist = Find_Plist_Elements();

// Инициализируем новую переменную
CxList dictionarySettings = All.NewCxList();

// Теперь добавим поиск всех интересующих нас значений. В дальнейшем можно расширять этот список.
// Для поиска значений, как ни странно, используется FindByMemberAccess - поиск обращений к методам. Второй параметр внутри функции, false, означает, что поиск нечувствителен к регистру
dictionarySettings.Add(plist.FindByMemberAccess("privatekey", false));
dictionarySettings.Add(plist.FindByMemberAccess("privatetoken", false));

// Для корректного поиска из-за особенностей структуры plist - нужно искать по типу "If statement"
CxList ifStatements = plist.FindByType(typeof(IfStmt));

// Добавляем в результат, перед этим получив родительский узел - для правильного отображения
result = dictionarySettings.FindByFathers(ifStatements);

ಕಾರ್ಯ: XML ನಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಲಾಗುತ್ತಿದೆ

ಪರಿಹಾರ: ಚೆಕ್‌ಮಾರ್ಕ್ಸ್ XML ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಮತ್ತು ಮೌಲ್ಯಗಳು, ಟ್ಯಾಗ್‌ಗಳು, ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ಹುಡುಕಲು ತುಂಬಾ ಅನುಕೂಲಕರ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ. ಆದರೆ, ದುರದೃಷ್ಟವಶಾತ್, ದಾಖಲಾತಿಯಲ್ಲಿ ದೋಷವಿತ್ತು, ಇದರಿಂದಾಗಿ ಒಂದೇ ಒಂದು ಉದಾಹರಣೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ದಸ್ತಾವೇಜನ್ನು ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯಲ್ಲಿ ಈ ದೋಷವನ್ನು ತೆಗೆದುಹಾಕಲಾಗಿದೆ ಎಂಬ ವಾಸ್ತವದ ಹೊರತಾಗಿಯೂ, ನೀವು ದಾಖಲೆಗಳ ಹಿಂದಿನ ಆವೃತ್ತಿಗಳನ್ನು ಬಳಸಿದರೆ ಜಾಗರೂಕರಾಗಿರಿ.

ದಾಖಲಾತಿಯಿಂದ ತಪ್ಪಾದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

// Код работать не будет
result = All.FindXmlAttributesByNameAndValue("*.app", 8, “id”, "error- section", false, true);

ಮರಣದಂಡನೆ ಪ್ರಯತ್ನದ ಪರಿಣಾಮವಾಗಿ, ನಾವು ದೋಷವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ All ಅಂತಹ ಯಾವುದೇ ವಿಧಾನವಿಲ್ಲ ... ಮತ್ತು ಇದು ನಿಜ, ಏಕೆಂದರೆ XML ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು ವಿಶೇಷವಾದ, ಪ್ರತ್ಯೇಕ ವಸ್ತು ಸ್ಥಳವಿದೆ - cxXPath. HTTP ಟ್ರಾಫಿಕ್ ಬಳಕೆಯನ್ನು ಅನುಮತಿಸುವ Android ನಲ್ಲಿ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಹುಡುಕಲು ಸರಿಯಾದ ಪ್ರಶ್ನೆಯು ಹೀಗಿದೆ:

// Правильный вариант с использованием cxXPath
result = cxXPath.FindXmlAttributesByNameAndValue("*.xml", 8, "cleartextTrafficPermitted", "true", false, true);

ಅದನ್ನು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ವಿವರವಾಗಿ ನೋಡೋಣ, ಏಕೆಂದರೆ ಎಲ್ಲಾ ಕಾರ್ಯಗಳ ಸಿಂಟ್ಯಾಕ್ಸ್ ಒಂದೇ ಆಗಿರುವುದರಿಂದ, ನೀವು ಒಂದನ್ನು ಕಂಡುಕೊಂಡ ನಂತರ, ನಿಮಗೆ ಬೇಕಾದುದನ್ನು ನೀವು ಆರಿಸಬೇಕಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಿಯತಾಂಕಗಳ ಪ್ರಕಾರ ಅನುಕ್ರಮವಾಗಿ:

• "*.xml"- ಹುಡುಕಬೇಕಾದ ಫೈಲ್‌ಗಳ ಮುಖವಾಡ

• 8 - ನಿಯಮವನ್ನು ಅನ್ವಯಿಸುವ ಭಾಷೆಯ ಐಡಿ

• "cleartextTrafficPermitted"- xml ನಲ್ಲಿ ಗುಣಲಕ್ಷಣದ ಹೆಸರು

• "true" - ಈ ಗುಣಲಕ್ಷಣದ ಮೌಲ್ಯ

• false - ಹುಡುಕುವಾಗ ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಯ ಬಳಕೆ

• true - ಅಂದರೆ ಕೇಸ್ ಅನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ ಹುಡುಕಾಟವನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ, ಅಂದರೆ ಕೇಸ್-ಸೆನ್ಸಿಟಿವ್

ಉದಾಹರಣೆಯಾಗಿ, ಎಚ್‌ಟಿಟಿಪಿ ಪ್ರೋಟೋಕಾಲ್ ಮೂಲಕ ಸರ್ವರ್‌ನೊಂದಿಗೆ ಸಂವಹನವನ್ನು ಅನುಮತಿಸುವ Android ನಲ್ಲಿನ ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಭದ್ರತಾ ದೃಷ್ಟಿಕೋನದಿಂದ ತಪ್ಪಾಗಿ ಗುರುತಿಸುವ ನಿಯಮವನ್ನು ನಾವು ಬಳಸಿದ್ದೇವೆ. ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿರುವ ಸೆಟ್ಟಿಂಗ್‌ನ ಉದಾಹರಣೆ cleartextTrafficPermitted ಅರ್ಥದೊಂದಿಗೆ true:

<network-security-config>
    <domain-config>
        <domain includeSubdomains="true">example.com</domain>
        <trust-anchors>
            <certificates src="@raw/my_ca"/>
        </trust-anchors>
        <domain-config cleartextTrafficPermitted="true">
            <domain includeSubdomains="true">secure.example.com</domain>
        </domain-config>
    </domain-config>
</network-security-config>

ಕಾರ್ಯ: ಫೈಲ್ ಹೆಸರು/ಪಾತ್ ಮೂಲಕ ಫಲಿತಾಂಶಗಳನ್ನು ಮಿತಿಗೊಳಿಸಿ

ಪರಿಹಾರ: Android ಗಾಗಿ ಮೊಬೈಲ್ ಅಪ್ಲಿಕೇಶನ್‌ನ ಅಭಿವೃದ್ಧಿಗೆ ಸಂಬಂಧಿಸಿದ ದೊಡ್ಡ ಯೋಜನೆಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿ, ಅಸ್ಪಷ್ಟತೆಯ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ನಿರ್ಧರಿಸುವ ನಿಯಮದ ತಪ್ಪು ಧನಾತ್ಮಕತೆಯನ್ನು ನಾವು ಎದುರಿಸಿದ್ದೇವೆ. ಸತ್ಯವೆಂದರೆ ನಿಯಮದ ಹೊರಗಿರುವ ನಿಯಮವು ಫೈಲ್‌ನಲ್ಲಿ ಹುಡುಕುತ್ತದೆ build.gradle ಅಪ್ಲಿಕೇಶನ್‌ನ ಬಿಡುಗಡೆಯ ಆವೃತ್ತಿಗೆ ಅಸ್ಪಷ್ಟ ನಿಯಮಗಳನ್ನು ಅನ್ವಯಿಸಲು ಜವಾಬ್ದಾರಿಯುತ ಸೆಟ್ಟಿಂಗ್.

ಆದರೆ ದೊಡ್ಡ ಯೋಜನೆಗಳಲ್ಲಿ ಕೆಲವೊಮ್ಮೆ ಮಕ್ಕಳ ಫೈಲ್‌ಗಳು ಇರುತ್ತವೆ build.gradle, ಇದು ಯೋಜನೆಯಲ್ಲಿ ಸೇರಿಸಲಾದ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ. ವಿಶಿಷ್ಟತೆಯೆಂದರೆ, ಈ ಫೈಲ್‌ಗಳು ಅಸ್ಪಷ್ಟತೆಯ ಅಗತ್ಯವನ್ನು ಸೂಚಿಸದಿದ್ದರೂ ಸಹ, ಸಂಕಲನದ ಸಮಯದಲ್ಲಿ ಮೂಲ ಅಸೆಂಬ್ಲಿ ಫೈಲ್‌ನ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.

ಹೀಗಾಗಿ, ಗ್ರಂಥಾಲಯಗಳಿಗೆ ಸೇರಿದ ಮಕ್ಕಳ ಫೈಲ್‌ಗಳಲ್ಲಿ ಟ್ರಿಗ್ಗರ್‌ಗಳನ್ನು ಕತ್ತರಿಸುವುದು ಕಾರ್ಯವಾಗಿದೆ. ರೇಖೆಯ ಉಪಸ್ಥಿತಿಯಿಂದ ಅವುಗಳನ್ನು ಗುರುತಿಸಬಹುದು apply 'com.android.library'.

ಫೈಲ್‌ನಿಂದ ಉದಾಹರಣೆ ಕೋಡ್ build.gradle, ಇದು ಅಸ್ಪಷ್ಟತೆಯ ಅಗತ್ಯವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 24
    buildToolsVersion "24.0.2"
    defaultConfig {
        ...
    }

    buildTypes {
        release {
            minifyEnabled true
            ...
        }
    }
}

dependencies {
  ...
}

ಫೈಲ್ ಉದಾಹರಣೆ build.gradle ಈ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಹೊಂದಿರದ ಯೋಜನೆಯಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ಗ್ರಂಥಾಲಯಕ್ಕಾಗಿ:

apply plugin: 'android-library'

dependencies {
  compile 'com.android.support:support-v4:18.0.+'
}

android {
  compileSdkVersion 14
  buildToolsVersion '17.0.0'
  ...
}

ಮತ್ತು ಚೆಕ್‌ಮಾರ್ಕ್‌ನ ನಿಯಮ:

ProGuardObfuscationNotInUse

// Поиск метода release среди всех методов в Gradle файлах
CxList releaseMethod = Find_Gradle_Method("release");

// Все объекты из файлов build.gradle
CxList gradleBuildObjects = Find_Gradle_Build_Objects();

// Поиск того, что находится внутри метода "release" среди всех объектов из файлов build.gradle
CxList methodInvokesUnderRelease = gradleBuildObjects.FindByType(typeof(MethodInvokeExpr)).GetByAncs(releaseMethod);

// Ищем внутри gradle-файлов строку "com.android.library" - это значит, что данный файл относится к библиотеке и его необходимо исключить из правила
CxList android_library = gradleBuildObjects.FindByName("com.android.library");

// Инициализация пустого массива
List<string> libraries_path = new List<string> {};

// Проходим через все найденные "дочерние" файлы
foreach(CxList library in android_library)
{
    // Получаем путь к каждому файлу
	string file_name_library = library.GetFirstGraph().LinePragma.FileName;
    
    // Добавляем его в наш массив
	libraries_path.Add(file_name_library);
}

// Ищем все вызовы включения обфускации в релизных настройках
CxList minifyEnabled = methodInvokesUnderRelease.FindByShortName("minifyEnabled");

// Получаем параметры этих вызовов
CxList minifyValue = gradleBuildObjects.GetParameters(minifyEnabled, 0);

// Ищем среди них включенные
CxList minifyValueTrue = minifyValue.FindByShortName("true");

// Немного магии, если не нашли стандартным способом :D
if (minifyValueTrue.Count == 0) {
	minifyValue = minifyValue.FindByAbstractValue(abstractValue => abstractValue is TrueAbstractValue);
} else {
    // А если всё-таки нашли, то предыдущий результат и оставляем
	minifyValue = minifyValueTrue;	
}

// Если не нашлось таких методов
if (minifyValue.Count == 0)
{
    // Для более корректного отображения места срабатывания в файле ищем или buildTypes или android
	CxList tempResult = All.NewCxList();
	CxList buildTypes = Find_Gradle_Method("buildTypes");
	if (buildTypes.Count > 0) {
		tempResult = buildTypes;
	} else {
		tempResult = Find_Gradle_Method("android");
	}
	
	// Для каждого из найденных мест срабатывания проходим и определяем, дочерний или основной файлы сборки
	foreach(CxList res in tempResult)
	{
        // Определяем, в каком файле был найден buildType или android методы
		string file_name_result = res.GetFirstGraph().LinePragma.FileName;
        
        // Если такого файла нет в нашем списке "дочерних" файлов - значит это основной файл и его можно добавить в результат
		if (libraries_path.Contains(file_name_result) == false){
			result.Add(res);
		}
	}
}

ಈ ವಿಧಾನವು ಸಾಕಷ್ಟು ಸಾರ್ವತ್ರಿಕವಾಗಿದೆ ಮತ್ತು ಆಂಡ್ರಾಯ್ಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಮಾತ್ರವಲ್ಲದೆ ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿಯೂ ಸಹ ಫಲಿತಾಂಶವು ನಿರ್ದಿಷ್ಟ ಫೈಲ್‌ಗೆ ಸೇರಿದೆಯೇ ಎಂದು ನೀವು ನಿರ್ಧರಿಸಬೇಕಾದಾಗ.

ಕಾರ್ಯ: ಸಿಂಟ್ಯಾಕ್ಸ್ ಸಂಪೂರ್ಣವಾಗಿ ಬೆಂಬಲಿತವಾಗಿಲ್ಲದಿದ್ದರೆ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಲೈಬ್ರರಿಗೆ ಬೆಂಬಲವನ್ನು ಸೇರಿಸಿ

ಪರಿಹಾರ: ಕೋಡ್ ಬರೆಯುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಬಳಸಲಾಗುವ ವಿವಿಧ ಚೌಕಟ್ಟುಗಳ ಸಂಖ್ಯೆಯು ಚಾರ್ಟ್‌ಗಳಿಂದ ಹೊರಗಿದೆ. ಸಹಜವಾಗಿ, ಚೆಕ್ಮಾರ್ಕ್ಸ್ ಯಾವಾಗಲೂ ತಮ್ಮ ಅಸ್ತಿತ್ವದ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದಿಲ್ಲ, ಮತ್ತು ಕೆಲವು ವಿಧಾನಗಳು ನಿರ್ದಿಷ್ಟವಾಗಿ ಈ ಚೌಕಟ್ಟಿಗೆ ಸೇರಿವೆ ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಅದನ್ನು ಕಲಿಸುವುದು ನಮ್ಮ ಕಾರ್ಯವಾಗಿದೆ. ಚೌಕಟ್ಟುಗಳು ಬಹಳ ಸಾಮಾನ್ಯವಾದ ಕಾರ್ಯದ ಹೆಸರುಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಕೆಲವೊಮ್ಮೆ ಇದು ಸಂಕೀರ್ಣವಾಗಿದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಗ್ರಂಥಾಲಯಕ್ಕೆ ನಿರ್ದಿಷ್ಟ ಕರೆಯ ಸಂಬಂಧವನ್ನು ನಿಸ್ಸಂದಿಗ್ಧವಾಗಿ ನಿರ್ಧರಿಸಲು ಅಸಾಧ್ಯವಾಗಿದೆ.

ತೊಂದರೆಯೆಂದರೆ ಅಂತಹ ಗ್ರಂಥಾಲಯಗಳ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಯಾವಾಗಲೂ ಸರಿಯಾಗಿ ಗುರುತಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ತಪ್ಪು ಧನಾತ್ಮಕತೆಯನ್ನು ಪಡೆಯುವುದನ್ನು ತಪ್ಪಿಸಲು ನೀವು ಪ್ರಯೋಗವನ್ನು ಮಾಡಬೇಕು. ಸ್ಕ್ಯಾನಿಂಗ್ ನಿಖರತೆಯನ್ನು ಸುಧಾರಿಸಲು ಮತ್ತು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಹಲವಾರು ಆಯ್ಕೆಗಳಿವೆ:

• ಮೊದಲ ಆಯ್ಕೆ, ಲೈಬ್ರರಿಯನ್ನು ನಿರ್ದಿಷ್ಟ ಯೋಜನೆಯಲ್ಲಿ ಬಳಸಲಾಗಿದೆ ಮತ್ತು ತಂಡದ ಮಟ್ಟದಲ್ಲಿ ನಿಯಮವನ್ನು ಅನ್ವಯಿಸಬಹುದು ಎಂದು ನಮಗೆ ಖಚಿತವಾಗಿ ತಿಳಿದಿದೆ. ಆದರೆ ತಂಡವು ವಿಭಿನ್ನ ವಿಧಾನವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ನಿರ್ಧರಿಸಿದರೆ ಅಥವಾ ಕಾರ್ಯದ ಹೆಸರುಗಳು ಅತಿಕ್ರಮಿಸುವ ಹಲವಾರು ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿದರೆ, ನಾವು ಹಲವಾರು ತಪ್ಪು ಧನಾತ್ಮಕತೆಯ ಅತ್ಯಂತ ಆಹ್ಲಾದಕರ ಚಿತ್ರವನ್ನು ಪಡೆಯಬಹುದು.

• ಲೈಬ್ರರಿಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಆಮದು ಮಾಡಿಕೊಂಡಿರುವ ಫೈಲ್‌ಗಳನ್ನು ಹುಡುಕುವುದು ಎರಡನೆಯ ಆಯ್ಕೆಯಾಗಿದೆ. ಈ ವಿಧಾನದೊಂದಿಗೆ, ನಮಗೆ ಅಗತ್ಯವಿರುವ ಲೈಬ್ರರಿಯನ್ನು ಈ ಫೈಲ್‌ನಲ್ಲಿ ನಿಖರವಾಗಿ ಬಳಸಲಾಗಿದೆ ಎಂದು ನಾವು ಖಚಿತವಾಗಿ ಹೇಳಬಹುದು.

• ಮತ್ತು ಮೇಲಿನ ಎರಡು ವಿಧಾನಗಳನ್ನು ಒಟ್ಟಿಗೆ ಬಳಸುವುದು ಮೂರನೇ ಆಯ್ಕೆಯಾಗಿದೆ.

ಉದಾಹರಣೆಯಾಗಿ, ಕಿರಿದಾದ ವಲಯಗಳಲ್ಲಿ ಪ್ರಸಿದ್ಧವಾದ ಗ್ರಂಥಾಲಯವನ್ನು ನೋಡೋಣ ನುಣುಪಾದ ಸ್ಕಾಲಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಾಗಿ, ಅವುಗಳೆಂದರೆ, ಕ್ರಿಯಾತ್ಮಕತೆ ಸ್ಪ್ಲೈಸಿಂಗ್ ಲಿಟರಲ್ ಮೌಲ್ಯಗಳು. ಸಾಮಾನ್ಯವಾಗಿ, SQL ಪ್ರಶ್ನೆಗೆ ನಿಯತಾಂಕಗಳನ್ನು ರವಾನಿಸಲು, ನೀವು ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಬೇಕು $, ಇದು ಪೂರ್ವರೂಪದ SQL ಪ್ರಶ್ನೆಗೆ ಡೇಟಾವನ್ನು ಬದಲಿಸುತ್ತದೆ. ಅಂದರೆ, ವಾಸ್ತವವಾಗಿ, ಇದು ಜಾವಾದಲ್ಲಿ ಸಿದ್ಧಪಡಿಸಿದ ಹೇಳಿಕೆಯ ನೇರ ಅನಲಾಗ್ ಆಗಿದೆ. ಆದರೆ, ನೀವು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ SQL ಪ್ರಶ್ನೆಯನ್ನು ನಿರ್ಮಿಸಬೇಕಾದರೆ, ಉದಾಹರಣೆಗೆ, ನೀವು ಟೇಬಲ್ ಹೆಸರುಗಳನ್ನು ರವಾನಿಸಬೇಕಾದರೆ, ನೀವು ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು #$, ಇದು ಡೇಟಾವನ್ನು ನೇರವಾಗಿ ಪ್ರಶ್ನೆಗೆ ಬದಲಿಸುತ್ತದೆ (ಬಹುತೇಕ ಸ್ಟ್ರಿಂಗ್ ಜೋಡಣೆಯಂತೆಯೇ).

ಮಾದರಿ ಕೋಡ್:

// В общем случае - значения, контролируемые пользователем
val table = "coffees"
sql"select * from #$table where name = $name".as[Coffee].headOption

ಸ್ಪ್ಲೈಸಿಂಗ್ ಲಿಟರಲ್ ವ್ಯಾಲ್ಯೂಸ್ ಮತ್ತು ಸ್ಕಿಪ್ ಆಪರೇಟರ್‌ಗಳ ಬಳಕೆಯನ್ನು ಹೇಗೆ ಕಂಡುಹಿಡಿಯುವುದು ಎಂದು ಚೆಕ್‌ಮಾರ್ಕ್ಸ್‌ಗೆ ಇನ್ನೂ ತಿಳಿದಿಲ್ಲ #$, ಆದ್ದರಿಂದ ಸಂಭಾವ್ಯ SQL ಇಂಜೆಕ್ಷನ್‌ಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಕೋಡ್‌ನಲ್ಲಿ ಸರಿಯಾದ ಸ್ಥಳಗಳನ್ನು ಹೈಲೈಟ್ ಮಾಡಲು ಅದನ್ನು ಕಲಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ:

// Находим все импорты
CxList imports = All.FindByType(typeof(Import));

// Ищем по имени, есть ли в импортах slick
CxList slick = imports.FindByShortName("slick");

// Некоторый флаг, определяющий, что импорт библиотеки в коде присутствует
// Для более точного определения - можно применить подход с именем файла
bool not_empty_list = false;
foreach (CxList r in slick)
{
    // Если встретили импорт, считаем, что slick используется
	not_empty_list = true;
}

if (not_empty_list) {
    // Ищем вызовы, в которые передается SQL-строка
	CxList sql = All.FindByShortName("sql");
	sql.Add(All.FindByShortName("sqlu"));
	
	// Определяем данные, которые попадают в эти вызовы
	CxList data_sql = All.DataInfluencingOn(sql);
	
	// Так как синтакис не поддерживается, можно применить подход с регулярными выражениями
	// RegExp стоит использовать крайне осторожно и не применять его на большом количестве данных, так как это может сильно повлиять на производительность
	CxList find_possible_inj = data_sql.FindByRegex(@"#$", true, true, true);

    // Избавляемся от лишних срабатываний, если они есть и выводим в результат
	result = find_possible_inj.FindByType(typeof(BinaryExpr));
}

ಕಾರ್ಯ: ಓಪನ್ ಸೋರ್ಸ್ ಲೈಬ್ರರಿಗಳಲ್ಲಿ ಬಳಸಿದ ದುರ್ಬಲ ಕಾರ್ಯಗಳಿಗಾಗಿ ಹುಡುಕಿ

ಪರಿಹಾರ: ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಲೈಬ್ರರಿಗಳ ದುರ್ಬಲ ಆವೃತ್ತಿಗಳ ಬಳಕೆಯನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಅನೇಕ ಕಂಪನಿಗಳು ಓಪನ್-ಸೋರ್ಸ್ ಮಾನಿಟರಿಂಗ್ ಟೂಲ್‌ಗಳನ್ನು (OSA ಅಭ್ಯಾಸ) ಬಳಸುತ್ತವೆ. ಕೆಲವೊಮ್ಮೆ ಅಂತಹ ಲೈಬ್ರರಿಯನ್ನು ಸುರಕ್ಷಿತ ಆವೃತ್ತಿಗೆ ನವೀಕರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಕ್ರಿಯಾತ್ಮಕ ಮಿತಿಗಳಿವೆ, ಇತರರಲ್ಲಿ ಯಾವುದೇ ಸುರಕ್ಷಿತ ಆವೃತ್ತಿ ಇಲ್ಲ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ದುರ್ಬಲತೆಯ ಶೋಷಣೆಗೆ ಕಾರಣವಾಗುವ ಕಾರ್ಯಗಳನ್ನು ಕೋಡ್‌ನಲ್ಲಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ನಿರ್ಧರಿಸಲು SAST ಮತ್ತು OSA ಅಭ್ಯಾಸಗಳ ಸಂಯೋಜನೆಯು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಆದರೆ ಕೆಲವೊಮ್ಮೆ, ವಿಶೇಷವಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪರಿಗಣಿಸುವಾಗ, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಕ್ಷುಲ್ಲಕ ಕಾರ್ಯವಲ್ಲ. ಕೆಳಗೆ ಒಂದು ಪರಿಹಾರವಾಗಿದೆ, ಬಹುಶಃ ಸೂಕ್ತವಲ್ಲ, ಆದರೆ ಅದೇನೇ ಇದ್ದರೂ, ಘಟಕದಲ್ಲಿನ ದುರ್ಬಲತೆಗಳ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ lodash ವಿಧಾನಗಳಲ್ಲಿ template и *set.

JS ಫೈಲ್‌ನಲ್ಲಿ ಪರೀಕ್ಷಾ ಸಂಭಾವ್ಯ ದುರ್ಬಲ ಕೋಡ್‌ನ ಉದಾಹರಣೆಗಳು:

/**
 * Template example
 */

'use strict';
var _ = require("./node_modules/lodash.js");


// Use the "interpolate" delimiter to create a compiled template.
var compiled = _.template('hello <%= js %>!');
console.log(compiled({ 'js': 'lodash' }));
// => 'hello lodash!'

// Use the internal `print` function in "evaluate" delimiters.

var compiled = _.template('<% print("hello " + js); %>!');
console.log(compiled({ 'js': 'lodash' }));
// => 'hello lodash!'

ಮತ್ತು ನೇರವಾಗಿ html ನಲ್ಲಿ ಸಂಪರ್ಕಿಸುವಾಗ:

<!DOCTYPE html>
<html>
<head>
    <title>Lodash Tutorial</title>
    <script src="./node_modules/lodash.js"></script>
    <script type="text/javascript">
  // Lodash chunking array
        nums = [1, 2, 3, 4, 5, 6, 7, 8, 9];

        let c1 = _.template('<% print("hello " + js); %>!');
        console.log(c1);

        let c2 = _.template('<% print("hello " + js); %>!');
        console.log(c2);
    </script>
</head>
<body></body>
</html>

ನಮ್ಮ ಎಲ್ಲಾ ದುರ್ಬಲ ವಿಧಾನಗಳನ್ನು ನಾವು ಹುಡುಕುತ್ತಿದ್ದೇವೆ, ಇವುಗಳನ್ನು ದುರ್ಬಲತೆಗಳಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆ:

// Ищем все строки: в которых встречается строка lodash (предполагаем, что это объявление импорта библиотеки
CxList lodash_strings = Find_String_Literal().FindByShortName("*lodash*");

// Ищем все данные: которые взаимодействуют с этими строками
CxList data_on_lodash = All.InfluencedBy(lodash_strings);


// Задаем список уязвимых методов
List<string> vulnerable_methods = new List<string> {"template", "*set"};

// Ищем все наши уязвимые методы, которые перечисленны в уязвимостях и отфильтровываем их только там, где они вызывались
CxList vulnerableMethods = All.FindByShortNames(vulnerable_methods).FindByType(typeof(MethodInvokeExpr));

//Находим все данные: которые взаимодействуют с данными методами
CxList vulnFlow = All.InfluencedBy(vulnerableMethods);

// Если есть пересечение по этим данным - кладем в результат
result = vulnFlow * data_on_lodash;

// Формируем список путей по которым мы уже прошли, чтобы фильтровать в дальнейшем дубли
List<string> lodash_result_path = new List<string> {};

foreach(CxList lodash_result in result)
{
    // Очередной раз получаем пути к файлам
	string file_name = lodash_result.GetFirstGraph().LinePragma.FileName;
	lodash_result_path.Add(file_name);
}

// Дальше идет часть относящаяся к html файлам, так как в них мы не можем проследить откуда именно идет вызов
// Формируем массив путей файлов, чтобы быть уверенными, что срабатывания уязвимых методов были именно в тех файлах, в которых объявлен lodash
List<string> lodash_path = new List<string> {};
foreach(CxList string_lodash in lodash_strings)
{
	string file_name = string_lodash.GetFirstGraph().LinePragma.FileName;
	lodash_path.Add(file_name);
}

// Перебираем все уязвимые методы и убеждаемся, что они вызваны в тех же файлах, что и объявление/включение lodash
foreach(CxList method in vulnerableMethods)
{
	string file_name_method = method.GetFirstGraph().LinePragma.FileName;
	if (lodash_path.Contains(file_name_method) == true && lodash_result_path.Contains(file_name_method) == false){
		result.Add(method);
	}
}

// Убираем все UknownReferences и оставляем самый "длинный" из путей, если такие встречаются
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceSmallFlow) - result.FindByType(typeof(UnknownReference));

ಕಾರ್ಯ: ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಎಂಬೆಡ್ ಮಾಡಿದ ಪ್ರಮಾಣಪತ್ರಗಳಿಗಾಗಿ ಹುಡುಕಲಾಗುತ್ತಿದೆ

ಪರಿಹಾರ: ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ವಿಶೇಷವಾಗಿ ಮೊಬೈಲ್‌ಗಳು, ವಿವಿಧ ಸರ್ವರ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಅಥವಾ SSL-ಪಿನ್ನಿಂಗ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು ಪ್ರಮಾಣಪತ್ರಗಳು ಅಥವಾ ಕೀಗಳನ್ನು ಬಳಸುವುದು ಅಸಾಮಾನ್ಯವೇನಲ್ಲ. ಭದ್ರತಾ ದೃಷ್ಟಿಕೋನದಿಂದ, ಅಂತಹ ವಿಷಯಗಳನ್ನು ಕೋಡ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸವಲ್ಲ. ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಒಂದೇ ರೀತಿಯ ಫೈಲ್‌ಗಳನ್ನು ಹುಡುಕುವ ನಿಯಮವನ್ನು ಬರೆಯಲು ಪ್ರಯತ್ನಿಸೋಣ:

// Найдем все сертификаты по маске файла
CxList find_certs = All.FindByShortNames(new List<string> {"*.der", "*.cer", "*.pem", "*.key"}, false);

// Проверим, где в приложении они используются
CxList data_used_certs = All.DataInfluencedBy(find_certs);

// И для мобильных приложений - можем поискать методы, где вызывается чтение сертификатов
// Для других платформ и приложений могут быть различные методы
CxList methods = All.FindByMemberAccess("*.getAssets");

// Пересечение множеств даст нам результат по использованию локальных сертификатов в приложении
result = methods * data_used_certs;

ಕಾರ್ಯ: ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ರಾಜಿ ಟೋಕನ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು

ಪರಿಹಾರ: ಕೋಡ್‌ನಲ್ಲಿರುವ ರಾಜಿ ಟೋಕನ್‌ಗಳು ಅಥವಾ ಇತರ ಪ್ರಮುಖ ಮಾಹಿತಿಯನ್ನು ಹಿಂತೆಗೆದುಕೊಳ್ಳುವುದು ಆಗಾಗ್ಗೆ ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ಸಹಜವಾಗಿ, ಅವುಗಳನ್ನು ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದು ಒಳ್ಳೆಯದಲ್ಲ, ಆದರೆ ಸನ್ನಿವೇಶಗಳು ಬದಲಾಗುತ್ತವೆ. CxQL ಪ್ರಶ್ನೆಗಳಿಗೆ ಧನ್ಯವಾದಗಳು, ಈ ರೀತಿಯ ವಿಷಯಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ತುಂಬಾ ಸುಲಭ:

// Получаем все строки, которые содержатся в коде
CxList strings = base.Find_Strings();

// Ищем среди всех строк нужное нам значение. В примере токен в виде строки "qwerty12345"
result = strings.FindByShortName("qwerty12345");

ತೀರ್ಮಾನಕ್ಕೆ

ಚೆಕ್ಮಾರ್ಕ್ಸ್ ಉಪಕರಣದೊಂದಿಗೆ ತಮ್ಮ ಪರಿಚಯವನ್ನು ಪ್ರಾರಂಭಿಸುವವರಿಗೆ ಈ ಲೇಖನವು ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಬಹುಶಃ ದೀರ್ಘಕಾಲದವರೆಗೆ ತಮ್ಮದೇ ಆದ ನಿಯಮಗಳನ್ನು ಬರೆಯುತ್ತಿರುವವರು ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ಉಪಯುಕ್ತವಾದದ್ದನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತಾರೆ.

ದುರದೃಷ್ಟವಶಾತ್, ಚೆಕ್‌ಮಾರ್ಕ್ಸ್‌ನ ನಿಯಮಗಳ ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ಹೊಸ ಆಲೋಚನೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದಾದ ಸಂಪನ್ಮೂಲದ ಕೊರತೆಯು ಪ್ರಸ್ತುತವಾಗಿದೆ. ಅದಕ್ಕಾಗಿಯೇ ನಾವು ರಚಿಸಿದ್ದೇವೆ Github ನಲ್ಲಿ ಭಂಡಾರ, ಅಲ್ಲಿ ನಾವು ನಮ್ಮ ಕೆಲಸವನ್ನು ಪೋಸ್ಟ್ ಮಾಡುತ್ತೇವೆ ಇದರಿಂದ CxQL ಅನ್ನು ಬಳಸುವ ಪ್ರತಿಯೊಬ್ಬರೂ ಅದರಲ್ಲಿ ಉಪಯುಕ್ತವಾದದ್ದನ್ನು ಕಂಡುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಸಮುದಾಯದೊಂದಿಗೆ ಅವರ ಕೆಲಸವನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಅವಕಾಶವಿದೆ. ರೆಪೊಸಿಟರಿಯು ವಿಷಯವನ್ನು ತುಂಬುವ ಮತ್ತು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿದೆ, ಆದ್ದರಿಂದ ಕೊಡುಗೆದಾರರಿಗೆ ಸ್ವಾಗತ!

ನಿಮ್ಮ ಗಮನಕ್ಕೆ ಧನ್ಯವಾದಗಳು!

ಮೂಲ: www.habr.com