गूंज के साथ गूंज

Question

मुझे स्क्रीन पर कुछ चर प्रिंट करने की आवश्यकता है, लेकिन मुझे पहले कुछ पात्रों को पूर्वनिर्धारित करने की आवश्यकता है और मैं सोच रहा था कि क्या बैश में एक गूंज कमांड थी जो टर्मिनल पर इसे प्रिंट करने के लिए एक गुप्त मूल्य के पहले वर्णों को बाधित कर सकती है:

echo 'secretvalue'
********lue

Answer 1

अन्य उत्तर प्रारंभ से वर्णों की एक निश्चित मात्रा का मुखौटा लगाते हैं, जिसमें सादा प्रत्यय लंबाई में भिन्न होता है। एक विकल्प यह होगा कि प्लेटेक्स्ट में पात्रों की एक निश्चित मात्रा को छोड़ दिया जाए, और नकाबपोश हिस्से की लंबाई अलग-अलग कर दी जाए। मुझे नहीं पता कि कौन सा अधिक उपयोगी है, लेकिन यहां दूसरी पसंद है:

#!/bin/bash
mask() {
        local n=3                    # number of chars to leave
        local a="${1:0:${#1}-n}"     # take all but the last n chars
        local b="${1:${#1}-n}"       # take the final n chars 
        printf "%s%s\n" "${a//?/*}" "$b"   # substitute a with asterisks
}

mask abcde
mask abcdefghijkl

यह प्रिंट **cdeऔर *********jkl।

---

यदि आप चाहें, तो आप यह nसुनिश्चित करने के लिए कि छोटे तार के लिए संशोधित कर सकते हैं स्ट्रिंग के अधिकांश नकाबपोश हो जाते हैं। उदाहरण के लिए, यह सुनिश्चित करता है कि कम से कम तीन अक्षर छोटे तारों के लिए भी नकाब लगाए हों। (अतः abcde-> ***de, और abc-> ***):

mask() {
        local n=3
        [[ ${#1} -le 5 ]] && n=$(( ${#1} - 3 ))
        local a="${1:0:${#1}-n}"
        local b="${1:${#1}-n}"
        printf "%s%s\n" "${a//?/*}" "$b"
}

Answer 2

एक विकल्प अपने आप को इसके बजाय एक समारोह का उपयोग करने के लिए मजबूर करना होगा echo, जैसे:

obfuprint() {
  if [ "${#1}" -ge 8 ]
  then
    printf '%s\n' "${1/????????/********}"
  else
    printf '%s\n' "${1//?/*}"
  fi
}

तब आप कॉल कर सकते हैं obfuprint 'secretvalue'और प्राप्त कर सकते हैं ********lue(अनुगामी न्यूलाइन के साथ)। फ़ंक्शन पास-इन मान के पहले आठ वर्णों की खोज के लिए पैरामीटर विस्तार का उपयोग करता है और उन्हें आठ तारांकन के साथ बदलता है। यदि आवक मान आठ वर्णों से कम है, तो वे सभी तारांकन के साथ बदल दिए जाते हैं। आठ या अधिक चरित्र इनपुट की मेरी प्रारंभिक धारणा को इंगित करने के लिए ilkachach का धन्यवाद !

---

Ilkachachu के लचीले मास्किंग जवाब से प्रेरित होकर , मैंने सोचा कि यह एक भिन्नता जोड़ना दिलचस्प होगा जो बेतरतीब ढंग से स्ट्रिंग के कुछ प्रतिशत को मास्क करता है:

obfuprintperc () {
  local perc=75  ## percent to obfuscate
  local i=0
  for((i=0; i < ${#1}; i++))
  do
    if [ $(( $RANDOM % 100 )) -lt "$perc" ]
    then
        printf '%s' '*'
    else
        printf '%s' "${1:i:1}"
    fi
  done
  echo
}

यह बैश के $RANDOMविशेष चर पर निर्भर करता है ; यह बस इनपुट के प्रत्येक चरित्र के माध्यम से लूप करता है और यह तय करता है कि उस चरित्र को मुखौटा करना है या इसे प्रिंट करना है। नमूना उत्पादन:

$ obfuprintperc 0123456789
0*****6*8*
$ obfuprintperc 0123456789
012***678*
$ obfuprintperc 0123456789
**********
$ obfuprintperc 0123456789
*****56***
$ obfuprintperc 0123456789
0*******8*

Comments

फ्रैंक होने के लिए, मुझे यादृच्छिक मास्किंग पसंद नहीं है। एक निर्धारित कंधे सर्फर अंततः मेरे साथ छोटी सी बात करने का बहाना करके मेरे रहस्यों को प्राप्त करेगा।

— एमोरी

निश्चित रूप से, संवेदनशील जानकारी प्रदर्शित करना सावधानी से किया जाना चाहिए! मैंने निश्चित-उपसर्ग मास्किंग और चर-उपसर्ग मास्किंग के विकल्प के रूप में यादृच्छिक मास्किंग प्रस्तुत किया।

— जेफ स्कालर

मैं फिक्स्ड-प्रीफ़िक्स या वैरिएबल-प्रीफ़िक्स मास्किंग का प्रशंसक नहीं हूं, लेकिन उन लोगों के साथ मेरे रहस्य का "कर्नेल" मौजूद है जो गुप्त रहता है। यादृच्छिक मास्किंग के साथ, कोई "कर्नेल" नहीं है। आखिरकार उन मरीजों के लिए सबकुछ पर्याप्त हो जाएगा।

— एमोरी

Answer 3

आप पाइपिंग की कोशिश कर सकते हैं sed। उदाहरण के लिए, तार के पहले 8 अक्षरों को तारांकन के साथ बदलने के लिए, आप sed 's/^......../********/'कमांड पर पाइप कर सकते हैं , जैसे:

$ echo 'secretvalue' | sed 's/^......../********/'
********lue

आप ऐसा करने वाले फ़ंक्शन को भी परिभाषित कर सकते हैं:

obsecho () { echo "$1" | sed 's/^......../*********/'; }

Comments

मेरा सुझाव था printfसे अधिकecho इस तरह के रूप में डेटा की व्याख्या करने के लिए है कि आप विषय नहीं कर रहे हैं तो \rया\n

— जेफ स्कालर

@JeffSchaller यह एक कारण है कि मैं एसई पर पोस्ट क्यों करता हूं। अच्छी बात। प्रतिक्रिया के लिए धन्यवाद।

— alगल

यह उन कई चीज़ों में से एक है जो मैंने अपने समय में यहाँ भी सीखी हैं! इसे पास करने के लिए खुश!

— जेफ स्कालर

पाइप का उपयोग करने की आवश्यकता नहीं है जब आप इसके बजाय एक हेस्ट्रिंग का उपयोग कर सकते हैं:sed 's/^......../********/' <<< 'secretvalue'

— wjandrea

@roaima यह वास्तव में एक अस्थायी नियमित फ़ाइल है। आप इसे देख सकते हैं यदि आप करते हैं bash -c 'lsof -d0 -a -p $$ 2>/dev/null' <<< foo।

— जोएल

Answer 4

एक zshप्रकार जो पाठ के तीन तिमाहियों को मास्क करता है:

mask() printf '%s\n' ${(l:$#1::*:)1:$#1*3/4}

उदाहरण:

$ mask secretvalue
********lue
$ mask 12345678
******78
$ mask 1234
***4

पहले 8 वर्णों का मुखौटा लगाने के लिए:

mask() printf '%s\n' ${(l:$#1::*:)1:8}

सभी नकाबपोश लेकिन अंतिम 3 वर्णों के लिए:

mask() printf '%s\n' ${(l:$#1::*:)1: -3}

अक्षरों की एक यादृच्छिक संख्या को मुखौटा करने के लिए:

mask() printf '%s\n' ${(l:$#1::*:)1: RANDOM%$#1}

Answer 5

बैश में एक और विकल्प, अगर आपको एक सरल नहीं लगता है, तो आप evalइसे कुछ के साथ कर सकते हैं printf:

# example data
password=secretvalue
chars_to_show=3

# the real thing
eval "printf '*%.0s' {1..$((${#password} - chars_to_show))}"
printf '%s\n' "${password: -chars_to_show}"

लेकिन सावधान रहना:

• जब जरूरत ${#password}से कम हो तो उपरोक्त को ठीक करें${chars_to_show}
• evalअविश्वासित इनपुट के साथ बहुत खतरनाक हो सकता है: यहां इसे सुरक्षित माना जा सकता है क्योंकि इसका इनपुट सुरक्षित स्रोतों से ही आता है, अर्थात इसकी लंबाई ${password}और मूल्य${chars_to_show}

Answer 6

यहाँ कुछ खिलौना बैश स्क्रिप्ट है जो शो के साथ खेलने के लिए कैसे स्ट्रिंग प्रतिस्थापन के साथ रेगेक्स जैसी खोज को जोड़ती है।

strip_str.sh

#!/usr/bin/env bash

_str="${1}"
_filter="${2:-'apl'}"
echo "${_str//[${_filter}]/}"

strip_str.sh 'apple-foo bar'
# -> e-foo br
strip_str.sh 'apple-foo bar' 'a'
# -> pple-foo br

privatize_str.sh

#!/usr/bin/env bash

_str="${1}"
_filter="${2:-'apl'}"
_replace="${3:-'*'}"
echo "${_str//[${_filter}]/${_replace}}"

privatize_str.sh 'apple-foo bar'
# -> ****e-foo b*r

restricted_str.sh

#!/usr/bin/env bash

_str="${1}"
_valid="${2:-'a-z'}"
_replace="${3:-''}"
echo "${_str//[^${_valid}]/${_replace}}"

restricted_str.sh 'apple-foo bar'
# -> applefoobar

---

चाबी छीन लेना

• [a-z 0-9]बैश <search>के ${_var_name//<search>/<replace>}लिए एक पूरी तरह से वैध और उपयोगी है
• ^, इस संदर्भ में, notरेगेक्स जैसी खोजों के लिए उल्टा है
• बिल्ट-इन आम तौर पर तेजी से होते हैं और अक्सर अधिक संक्षिप्त होते हैं, खासकर जब यह अनावश्यक पाइपिंग को काटता है

जब मैं प्राप्त कि printfहै बेहतर लगभग सभी उपयोग के मामलों में उपरोक्त कोड का उपयोग करता है echoबहुत ज्यादा भ्रमित नहीं क्या हो रहा है के रूप में तो।

obfuscate_str.sh

#!/usr/bin/env bash

_str="${1}"
_start="${2:-6}"
_header="$(for i in {1..${_start}}; do echo -n '*'; done)"
echo "${_header}${_str:${_start}}"

obfuscate_str.sh 'apple-foo bar' 3
# -> ***le-foo bar