ನಾನು ஓர் AI ಸುರಕ್ಷತಾ ಸ್ಕ್ಯಾನರ್ ಅನ್ನು ನಿರ್ಮಿಸಿದೆ — ನಂತರ ನನ್ನದೇ ಡಿಟೆಕ್ಟರ್‌ನಲ್ಲಿ ಒಂದು ಬಗ್ ಅನ್ನು ಪತ್ತೆಹಚ್ಚಿದೆ

Prompt injection ಎಂಬುದು LLM ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಪ್ರಮುಖ ಸುರಕ್ಷತಾ ಅಪಾಯವಾಗಿದೆ. ನೀವು ಮಾಡೆಲ್‌ಗೆ ಅದರ ಮೂಲ ಸೂಚನೆಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸುವಂತೆ ಹೇಳುವ ಪಠ್ಯವನ್ನು ನೀಡುತ್ತೀರಿ. ಕೆಲವೊಮ್ಮೆ, ಮಾಡೆಲ್ ಅದನ್ನು ಕೇಳಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ಇದನ್ನು ಪರೀಕ್ಷಿಸಲು ನಾನು AgentProbe ಅನ್ನು ನಿರ್ಮಿಸಿದೆ. ಇದು jailbreaks ಮತ್ತು data extraction ನಂತಹ 8 ವರ್ಗಗಳ ಮೂಲಕ 49 ಅಟ್ಯಾಕ್ ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ರವಾನಿಸುತ್ತದೆ. ಮಾಡೆಲ್ ಎಷ್ಟು ಬಾರಿ ವಿಫಲವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಇದು ವರದಿ ಮಾಡುತ್ತದೆ.

ನಿಜವಾದ ಪಾಠ ಸ್ಕ್ಯಾನರ್ ಬಗ್ಗೆ ಆಗಿರಲಿಲ್ಲ. ಅದು ನನ್ನ ಡಿಟೆಕ್ಷನ್ ಕೋಡ್‌ನಲ್ಲಿನ ಒಂದು ಬಗ್ ಆಗಿತ್ತು.

ಕಷ್ಟದ ಭಾಗ ಅಟ್ಯಾಕ್ ಮಾಡುವುದಲ್ಲ. ಕಷ್ಟದ ಭಾಗ ಡಿಟೆಕ್ಷನ್ ಮಾಡುವುದು.

ಮಾಡೆಲ್ ನಿಜವಾಗಿಯೂ ಅಟ್ಯಾಕ್ ಅನ್ನು ಪಾಲಿಸಿದೆಯೇ ಎಂದು ನೀವು ಹೇಗೆ ತಿಳಿಯುತ್ತೀರಿ? Keyword matching ಸುಲಭವಾದ ಮಾರ್ಗವಾಗಿದೆ. ನೀವು "I cannot help" ನಂತಹ ನಿರಾಕರಣೆಯ ಪದಗುಚ್ಛಗಳು ಅಥವಾ "developer mode" ನಂತಹ ಅನುಸರಣೆಯ ಪದಗುಚ್ಛಗಳಿಗಾಗಿ ಹುಡುಕುತ್ತೀರಿ.

ಆದರೆ ಮಾಡೆಲ್‌ಗಳು "hedge-then-comply" ಮಾದರಿಯನ್ನು ಬಳಸುತ್ತವೆ. ಅವು "I cannot help with that" ಎಂದು ಹೇಳುತ್ತವೆ, ಆದರೆ ನಂತರ ನಿರ್ಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ನೀಡುತ್ತವೆ. ಇಲ್ಲಿ ನಿರಾಕರಣೆಯ ಪದಗುಚ್ಛವು ಇರುವುದರಿಂದ keyword matching ವಿಫಲವಾಗುತ್ತದೆ.

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

ನಂತರ ನಾನು ನನ್ನ ಬಗ್ ಅನ್ನು ಪತ್ತೆಹಚ್ಚಿದೆ.

ನನ್ನ keyword ಡಿಟೆಕ್ಟರ್ "hedge-then-comply" ಮಾದರಿಯನ್ನು ಕಂಡಾಗ 1 ರ ಕಾನ್ಫಿಡೆನ್ಸ್ ಸ್ಕೋರ್ ಅನ್ನು ನೀಡಿತು. ಆದಾಗ್ಯೂ, ಕಾನ್ಫಿಡೆನ್ಸ್ 2 ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿದ್ದರೆ ಮಾತ್ರ ನನ್ನ ಕೋಡ್ keyword ಹಂತವನ್ನು ನಂಬುತ್ತಿತ್ತು.

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

ಇತರ LLMಗಳನ್ನು ಗ್ರೇಡ್ ಮಾಡಲು LLMಗಳನ್ನು ಬಳಸುವ ಬಗ್ಗೆ ಈ ತಪ್ಪು ನನಗೆ ಮೂರು ಪಾಠಗಳನ್ನು ಕಲಿಸಿತು:

  • ಜಡ್ಜ್ ಟಾರ್ಗೆಟ್ ಮಾಡೆಲ್‌ನಿಗಿಂತ ಹೆಚ್ಚು ಬುದ್ಧಿವಂತನಾಗಿರಬೇಕು. ಜಡ್ಜ್ ಮತ್ತು ಟಾರ್ಗೆಟ್ ಒಂದೇ ಗಾತ್ರದವಾಗಿದ್ದರೆ, ಅದು ಅದೇ blind spotsಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.
  • ನಿಖರತೆಯು ಸುಳ್ಳು ಹೇಳಬಹುದು. ಹೆಚ್ಚಿನ ಮಾಡೆಲ್‌ಗಳು ನಿರಾಕರಿಸಿದರೆ, ಯಾವಾಗಲೂ "refused" ಎಂದು ಹೇಳುವ ಜಡ್ಜ್ ನಿಖರವಾಗಿ ಕಾಣಿಸಬಹುದು ಆದರೆ ಅದು ಏನನ್ನೂ ಕಲಿಯುವುದಿಲ್ಲ. ಅದೃಷ್ಟವನ್ನು ಪರಿಗಣಿಸಲು Cohen's kappa ನಂತಹ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಬಳಸಿ.
  • ಜಡ್ಜ್ ಸ್ಥಿರವಾಗಿರಬೇಕು. ಒಂದೇ ಪರೀಕ್ಷೆಯನ್ನು ಐದು ಬಾರಿ ಮಾಡಿ. ಜಡ್ಜ್ ತನ್ನ ನಿರ್ಧಾರವನ್ನು ಬದಲಾಯಿಸಿದರೆ, ಫಲಿತಾಂಶವು ಅಸ್ಪಷ್ಟವಾಗಿರುತ್ತದೆ ಮತ್ತು ಮಾನವನ ಗಮನದ ಅಗತ್ಯವಿರುತ್ತದೆ.

ನೀವು LLMಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಈ ಅಂಶಗಳನ್ನು ನೆನಪಿಡಿ:

  • ಅನುಸರಣೆಯನ್ನು ಉಂಟುಮಾಡುವುದಕ್ಕಿಂತ ಅದನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ಕಷ್ಟ.
  • ಮೊದಲ ವಾಕ್ಯದಲ್ಲಿ ನಿರಾಕರಿಸಿ, ಎರಡನೇ ವಾಕ್ಯದಲ್ಲಿ ಪಾಲಿಸುವ ಮಾಡೆಲ್‌ಗಳ ಬಗ್ಗೆ ಎಚ್ಚರವಿರಲಿ.
  • LLM ಜಡ್ಜ್ ಅನ್ನು ಕುರುಡಾಗಿ ನಂಬಬೇಡಿ. ಅದರ ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಅಳೆಯಿರಿ.
  • ನಿಮ್ಮ ಬಗ್‌ಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಿ. ನನ್ನ ಸ್ವಂತ ದೋಷವನ್ನು ಪತ್ತೆಹಚ್ಚಿದ್ದು, ಒಂದು ಪರಿಪೂರ್ಣ ಲಾಂಚ್‌ನಿಂದ ಸಿಗುವതിಗಿಂತ ಹೆಚ್ಚು ಕಲಿಸಿತು.

Source: https://dev.to/nar1frames/i-built-an-ai-security-scanner-then-found-a-bug-in-my-own-detector-140a

Optional learning community: https://t.me/GyaanSetuAi