एक नया उपयोगकर्ता और पासवर्ड बनाना

103

मेरे पास एक काम है जो ubuntu 12.04 पर एक नया उपयोगकर्ता बनाता है;

- name: Add deployment user
    action: user name=deployer password=mypassword

यह अपेक्षित रूप से पूरा होता है, लेकिन जब मैं उस उपयोगकर्ता के रूप में लॉगिन करता हूं और पासवर्ड के साथ sudo करने का प्रयास करता हूं, तो मैंने इसे हमेशा गलत कहा है। मैं क्या गलत कर रहा हूं?

bash  shell  ubuntu  ansible 
— raphael_turtle
स्रोत
1
क्या आप एक ही पासवर्ड या ssh कीज से लॉग-इन कर रहे हैं? क्या आपने यह सुनिश्चित करने के लिए अपनी छाया फ़ाइल की जाँच की कि इसकी सामग्री अपेक्षित है? इसके अलावा आपके passwordसादे पाठ में नहीं होना चाहिए, बल्कि पहले से होना चाहिए।
— एमएक्स
मेरा पासवर्ड सादा है, क्या मैं इसका इस्तेमाल नहीं कर सकता? मुझे समझ में नहीं आता है कि इसे कैसे एन्क्रिप्ट किया जाए, या वास्तव में इसकी आवश्यकता है।
— राफेल_टर्टल

जवाबों:

101

यदि आप userमॉड्यूल के लिए Ansible का मैनुअल पढ़ते हैं , तो यह आपको विवरण के लिए Ansible-example github repo से निर्देशित करेगा कि कैसे passwordपैरामीटर का उपयोग करें ।

आप देखेंगे कि आपका पासवर्ड हैशेड होना चाहिए।

- hosts: all
  user: root
  vars:
    # created with:
    # python -c 'import crypt; print crypt.crypt("This is my Password", "$1$SomeSalt$")'
    password: $1$SomeSalt$UqddPX3r4kH3UL5jq5/ZI.

  tasks:
    - user: name=tset password={{password}}

यदि आपकी playbook या ansible कमांड लाइन में आपका पासवर्ड है जैसा कि सादे पाठ में है, तो इसका मतलब है कि आपकी छाया फ़ाइल में दर्ज किया गया पासवर्ड गलत है। इसका मतलब है कि जब आप अपने पासवर्ड के साथ प्रमाणित करने की कोशिश करेंगे तो इसका हैश कभी भी मेल नहीं खाएगा।

इसके अतिरिक्त, पासवर्ड पैरामीटर की कुछ बारीकियों और इसे सही ढंग से उपयोग करने के तरीके के बारे में उत्तर देने योग्य FAQ देखें ।

— Mxx
स्रोत
25
पारितोषिक के लिए धन्यवाद। मैं सिर्फ यह बताना चाहता था कि उपर्युक्त उपयोगकर्ता मॉड्यूल प्रलेखन openssl passwd -salt <salt> -1 <plaintext>पासवर्ड हैश उत्पन्न करने के लिए उपयोग करने की सिफारिश करता है, न कि आपके ऊपर जो पायथन वन-लाइनर है। मुझे पायथन से सही आउटपुट प्राप्त करने में कुछ परेशानी हुई, शायद मेरी खुद की अक्षमता के कारण और ओपनसेल कमांड ने बेहतर काम किया।
— ब्रेंडन वुड
6
आप ओएस के साथ उपयोग किए जाने वाले नमक को कैसे सिंक्रनाइज़ करते हैं?
— ब्रीडली
5
@ तुरंत: कोई ज़रूरत नहीं है - नमक हमेशा पासवर्ड के हिस्से के रूप में संग्रहीत किया जाता है ($ 1 $ thesalt $ thepasswordhash) जिसका अर्थ है कि यह एक ही हैश फ़ंक्शन का उपयोग करके OS के बीच पोर्टेबल है
— बेंजामिन डेल
3
एक हैश उत्पन्न करने के लिए इस अजगर कमांड का उपयोग करना मेरे लिए काम नहीं करता था। लेकिन मैंने /etc/shadowमैन्युअल रूप से पासवर्ड का उपयोग करने के बाद हैश पाया passwd <user>।
— डोकसपर
172

मुझे इसका उत्तर देने में बहुत देर हो सकती है लेकिन हाल ही में मुझे पता चला कि jinja2 फिल्टर में एन्क्रिप्टेड पासवर्ड की पीढ़ी को संभालने की क्षमता है। अपने में main.ymlमैं एन्क्रिप्टेड पासवर्ड उत्पन्न कर रहा हूँ:

- name: Creating user "{{ uusername }}" with admin access
  user: 
    name: {{ uusername }}
    password: {{ upassword | password_hash('sha512') }}
    groups: admin append=yes
  when:  assigned_role  == "yes"

- name: Creating users "{{ uusername }}" without admin access
  user:
    name: {{ uusername }}
    password: {{ upassword | password_hash('sha512') }}
  when:  assigned_role == "no"

- name: Expiring password for user "{{ uusername }}"
  shell: chage -d 0 "{{ uusername }}"

"uusername" और "upassword" को --extra-varsप्लेबुक और नोटिस के रूप में पारित किया जाता है, मैंने पास किए गए पासवर्ड को एन्क्रिप्ट करने के लिए यहाँ jinja2 फ़िल्टर का उपयोग किया है।

मैंने अपने ब्लॉग में इससे संबंधित ट्यूटोरियल नीचे जोड़ा है

— thinkingmonster
स्रोत
6
इस बात से बचने के लिए कि आइटम हमेशा "बदला हुआ" है, आप एक गुप्त "नमक" को पासवर्ड_हश के लिए 2 डी पैरामीटर के रूप में जोड़ सकते हैं।
— माइकल वायराज 23:15
11
@ माइकलविराज के सुझाव के अनुसार: 2 "नमक" परम जोड़ने से "परिवर्तित" से बचा जाता है। आप इसे एक चर के माध्यम से सेट कर सकते हैं, जैसे password={{upassword|password_hash('sha512', upassword_salt)}}। यह आपको एक चर तिजोरी में नमक डालने देता है , जैसा कि आप संभवतः upasswordदोनों कार्यों से बाहर रखते हुए भी करेंगे ।
— user85461
मैं @ bbaassssiiee की राज्य-जाँच भी लागू करूँगा और update_password: on_createपहले से निर्मित उपयोगकर्ताओं के लिए पासवर्ड की समाप्ति को रोकने के लिए इस उत्तर में उपयोगकर्ता मॉड्यूल जोड़ूँगा ।
— पागल
आपके महान उदाहरण के लिए धन्यवाद, इसने मुझे सही रास्ते पर ला दिया। फिर भी मुझे कुछ और चीजें करनी पड़ीं ताकि इसे मैक पर काम कर सकूं। एक मैक पर सबसे पहले क्रिप्ट का उपयोग करना संभव नहीं है इसलिए पासबुक पुस्तकालय को स्थापित करना आवश्यक है pip install passlib। फिर एक इनलाइन वॉल्ट एन्क्रिप्टेड स्ट्रिंग का उपयोग करने में सक्षम होने के लिए मुझे निम्नलिखित जोड़ के साथ पुन: स्वरूपित करना पड़ा password: {{ upassword | string | password_hash('sha512') }}:। यह त्रुटि संदेश से बचा जाता हैsecret must be unicode or bytes, not ansible.parsing.yaml.objects.AnsibleVaultEncryptedUnicode
— माइकल ऐकर
पासवर्ड सेट करने के लिए इस विधि का उपयोग करने के बावजूद: "{{my_password | string | password_hash ('sha512')}}" मैं अभी भी प्राप्त करूंगा - [चेतावनी]: इनपुट पासवर्ड ऐसा प्रतीत नहीं होता है कि हैशेड है। इस मॉड्यूल को ठीक से काम करने के लिए 'पासवर्ड' तर्क को एन्क्रिप्ट किया जाना चाहिए।
— openCivilisation
46

मैं एक और समाधान का प्रस्ताव करना चाहता हूं:

- name: Create madhead user
  user:
    name: madhead
    password: "{{ 'password' | password_hash('sha512') }}"
    shell: /bin/zsh
    update_password: on_create
  register: madhead
- name: Force madhead to change password
  shell: chage -d 0 madhead
  when: madhead.changed

यह बेहतर क्यों है? जैसे पहले से ही यहाँ उल्लेख किया गया है, अंसिबल नाटकों को उदासीन होना चाहिए। आपको उन्हें अनिवार्य शैली में कार्रवाई के अनुक्रम के रूप में नहीं, बल्कि एक वांछित राज्य, घोषणात्मक शैली की तरह सोचना चाहिए। परिणामस्वरूप आपको इसे कई बार चलाने और एक ही परिणाम प्राप्त करने में सक्षम होना चाहिए, एक ही सर्वर स्थिति।

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

सौभाग्य से, Ansible के पास मॉड्यूलupdate_password में विशेषता है जो इस मुद्दे को हल करती है। इसे रजिस्टर्ड वैरिएबल के साथ मिलाने पर आप उसका पासवर्ड भी तभी समाप्त कर सकते हैं जब यूजर वास्तव में अपडेट हो।user

ध्यान दें कि यदि आप उपयोगकर्ता के शेल को मैन्युअल रूप से बदलते हैं (मान लें, तो आपको वह शेल पसंद नहीं है, जिसे उसके खेलने के लिए मजबूर किया गया है) उपयोगकर्ता को अपडेट किया जाएगा, इस प्रकार उसका पासवर्ड समाप्त हो जाएगा।

यह भी ध्यान दें कि आप नाटकों में सादा पाठ प्रारंभिक पासवर्ड का आसानी से उपयोग कैसे कर सकते हैं। उन्हें कहीं और एनकोड करने और हैश पेस्ट करने की आवश्यकता नहीं है, आप इसके लिए जिनजा 2 फिल्टर का उपयोग कर सकते हैं । हालाँकि, यह एक सुरक्षा दोष हो सकता है यदि कोई आपके शुरू में करने से पहले लॉगिन करता है।

— पागल दिमाग
स्रोत
3
मुझे मेरे लिए काम करने वाला दूसरा उपाय नहीं मिला। फिर भी आप का जवाब सरल है और काम किया है। अगर मैं कर सकता, तो मैं आपको 5 अपवोट देना चाहूंगा।
— लेसी
मैं नहीं चाहता कि मेरा पासवर्ड उस तरह से हार्ड-कोडित हो :( क्या यह संभव है कि इसे ansible-vault से बाहर निकालें और इसे यहाँ इंजेक्ट करें? "{{ '{{vaulted_password}}' | password_hash('sha512') }}"ऐसा नहीं लगता कि काम नहीं कर रहा है ...
— dokaspar
क्या आपने कोशिश की है {{ vaulted_password | password_hash('sha512') }}, जहां vaulted_passwordतिजोरी में मूल्य की कुंजी है?
— मडहैड
update_password: on_createकाम करने के लिए प्रतीत नहीं होता है ( 2017 से इसके बारे में एक खुला बग है ), इसलिए पासवर्ड किसी भी समय बदल जाएगा उपयोगकर्ता पर एक राज्य परिवर्तन है।
— दिति
11

Ansible 'उपयोगकर्ता' मॉड्यूल में, उन का प्रबंधन करता है idempotent रास्ता। पहले कार्य के नीचे प्लेबुक में उपयोगकर्ता के लिए राज्य = वर्तमान की घोषणा की गई है । ध्यान दें कि पहली कार्रवाई में ' रजिस्टर: न्यूयुसर ' यह निर्धारित करने के लिए दूसरी कार्रवाई में मदद करता है कि उपयोगकर्ता नया है (newuser.changed == True) या मौजूदा ( newuser.changed==False), केवल एक बार पासवर्ड उत्पन्न करने के लिए।

अन्सिबल प्लेबुक में है:

tasks:
  - name: create deployment user
    user: 
      name: deployer 
      createhome: yes 
      state: present 
    register: newuser

  - name: generate random password for user only on creation
    shell: /usr/bin/openssl rand -base64 32 | passwd --stdin deployer
    when: newuser.changed
— bbaassssiiee
स्रोत
केवल एक समाधान मेरे लिए वॉल्ट पासवर्ड के साथ काम कर रहा है। आपका बहुत बहुत धन्यवाद।
— डेनिस सवेंको
कम से कम हाल ही में डेबियन आधारित वितरण पास के बाइनरी को लंबे जीएनयू विकल्प "--स्टिन" का समर्थन नहीं करते हैं।
— XXL
10

इस तरह की कोशिश करो

vars_prompt:
 - name: "user_password"    
   prompt: "Enter a password for the user"    
   private: yes    
   encrypt: "md5_crypt" #need to have python-passlib installed in local machine before we can use it    
   confirm: yes    
   salt_size: 7

 - name: "add new user" user: name="{{user_name}}" comment="{{description_user}}" password="{{user_password}}" home="{{home_dir}}" shell="/bin/bash"
— आर्टेम फेओफानोव
स्रोत
2
मुझे यह समाधान पसंद है कि यह स्क्रिप्ट चलाने पर पासवर्ड में टाइप करने की अनुमति देता है। बूटस्ट्रैप स्क्रिप्ट के लिए अच्छा समाधान जो हर बार नहीं चलना चाहिए। हालांकि, मैंने उबंटू के लिए "sha512_crypt" का इस्तेमाल किया।
— गुन्नर
6

इस उत्तर में भूमिका का उद्देश्य new_user_name के लिए यादृच्छिक पासवर्ड उत्पन्न करना और पासवर्ड को तुरंत समाप्त करना है। New_user_name को अपने पहले लॉगऑन पर पासवर्ड बदलने की आवश्यकता है।

create_user.yml:

---
# create_user playbook

- hosts: your_host_group
  become: True
  user: ansible

  roles:
    - create_user

भूमिकाओं / create_user / कार्य / main.yml:

---
# Generate random password for new_user_name and the new_user_name
# is required to change his/her password on first logon. 

- name: Generate password for new user
  shell: makepasswd --chars=20
  register: user_password

- name: Generate encrypted password
  shell: mkpasswd --method=SHA-512 {{ user_password.stdout }}
  register: encrypted_user_password

- name: Create user account
  user: name={{ new_user_name }}
        password={{ encrypted_user_password.stdout }}
        state=present
        append=yes
        shell="/bin/bash"
        update_password=always
  when: new_user_name is defined and new_user_name in uids
  register: user_created

- name: Force user to change password
  shell: chage -d 0 {{ new_user_name }}
  when: user_created.changed

- name: User created
  debug: msg="Password for {{ new_user_name }} is {{ user_password.stdout }}"
  when: user_created.changed

जब आप एक नया उपयोगकर्ता बनाना चाहते हैं:

ansible-playbook -i hosts.ini create_user.yml --extra-vars "new_user_name=kelvin"
— McKelvin
स्रोत
3

यह आसान तरीका है:

---
- name: Create user
  user: name=user shell=/bin/bash home=/srv/user groups=admin,sudo generate_ssh_key=yes ssh_key_bits=2048
- name: Set password to user
  shell: echo user:plain_text_password | sudo chpasswd
  no_log: True
— Lightmed
स्रोत
शेल: हमेशा रिपोर्ट किए जाने वाले परिवर्तन का कारण होगा।
— बबास्सिएइए
@datasmid आप no_log जोड़ सकते हैं: सही विकल्प docs.ansible.com/ansible/…
— Phill Pafford
3

इस तरह मेरे लिए काम किया

- hosts: main
  vars:
  # created with:
  #  python -c "from passlib.hash import sha512_crypt; print sha512_crypt.encrypt('<password>')"
  # above command requires the PassLib library: sudo pip install passlib
  - password: '$6$rounds=100000$H/83rErWaObIruDw$DEX.DgAuZuuF.wOyCjGHnVqIetVt3qRDnTUvLJHBFKdYr29uVYbfXJeHg.IacaEQ08WaHo9xCsJQgfgZjqGZI0'

tasks:

- user: name=spree password={{password}} groups=sudo,www-data shell=/bin/bash append=yes
  sudo: yes
— hecbuma
स्रोत
3

पूर्णता के लिए मैं एड-हॉक कमांड का उपयोग कर पोस्ट कर सकता हूं, क्योंकि वहां एक पकड़ भी है।

सबसे पहले लिनक्स सिस्टम पर उपलब्ध mkpasswd उपयोगिता का उपयोग करके एक एन्क्रिप्टेड पासवर्ड बनाने का प्रयास करें:

mkpasswd --method=SHA-512

फिर ansible ad-hock कमांड आज़माएँ:

ansible all -m user -a 'name=testuser shell=/bin/bash \
     comment="Test User" password=$6$XXXX' -k -u admin --sudo

लेकिन सुनिश्चित करें:

  1. कमांड सिंगल कोट्स में है और डबल नहीं है अन्यथा आपका पासवर्ड कभी काम नहीं करेगा
  2. आप इसे चलाते हैं --sudoया आप एक त्रुटि के साथ समाप्त होते हैं ( useradd: cannot lock /etc/passwd; try again later)
— pgaref
स्रोत
धन्यवाद दोस्त, मैं विशेष रूप से एडहॉक संस्करण की तलाश में था, और आपके द्वारा उल्लेख की गई यह बहुत ही उद्धरण समस्या थी
— अलेक्सापारोव
2

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

---
- hosts: [your hosts]
  tasks:
  - include_vars: [path to your encrypted vault file]
  - local_action: "command openssl passwd -salt '{{password_salt}}' -1 '{{password}}'"
    register: password_hash
  - user: >
        name=[your username]
        state=present
        password="{{password_hash.stdout}}"

अपनी तिजोरी फ़ाइल को डिक्रिप्ट करने के लिए "--स्क-वॉल्ट-पास" विकल्प का उपयोग करके इस कमांड को चलाएं (एन्क्रिप्टेड वॉल्ट को प्रबंधित करने के तरीके के बारे में जानकारी के लिए ansible-वॉल्ट देखें)।

— स्टीव मिडगली
स्रोत
2

कार्य passwordकरने के लिए अंसैबल userकार्य के लिए ( @ ब्रेडन वुड की टिप्पणी से) के लिए एन्क्रिप्टेड पासवर्ड कैसे बनाएं :

openssl passwd -salt 'some_plain_salt' -1 'some_plain_pass'

परिणाम जैसा दिखेगा:

$1$some_pla$lmVKJwdV3Baf.o.F0OOy71

userकार्य का उदाहरण :

- name: Create user
  user: name="my_user" password="$1$some_pla$lmVKJwdV3Baf.o.F0OOy71"

UPD: यहाँ और यहाँ SHA-512 का उपयोग करके क्रिप्ट देखें :

अजगर

$ python -c "import crypt, getpass, pwd; print crypt.crypt('password', '\$6\$saltsalt\$')"

$6$saltsalt$qFmFH.bQmmtXzyBY0s9v7Oicd2z4XSIecDzlB5KiA2/jctKu9YterLp8wwnSq.qc.eoxqOmSuNp2xS0ktL3nh/

पर्ल

$ perl -e 'print crypt("password","\$6\$saltsalt\$") . "\n"'

$6$saltsalt$qFmFH.bQmmtXzyBY0s9v7Oicd2z4XSIecDzlB5KiA2/jctKu9YterLp8wwnSq.qc.eoxqOmSuNp2xS0ktL3nh/

माणिक

$ ruby -e 'puts "password".crypt("$6$saltsalt$")'

$6$saltsalt$qFmFH.bQmmtXzyBY0s9v7Oicd2z4XSIecDzlB5KiA2/jctKu9YterLp8wwnSq.qc.eoxqOmSuNp2xS0ktL3nh/
— डिमिट्री
स्रोत
1
क्या यह md5 हैशेड पासवर्ड जनरेट नहीं कर रहा है? क्या वह असुरक्षित नहीं है?
— मार्क
2

आप playbooks में गुप्त कुंजी का उपयोग करने के लिए ansible-वॉल्ट का उपयोग कर सकते हैं। अपना पासवर्ड yml में परिभाषित करें।

पूर्व। पास: गुप्त या

user:
  pass: secret
  name: fake

अपनी गुप्त फ़ाइल को इनक्रिप्ट करें:

ansible-vault encrypt /path/to/credential.yml

ansible इसे एन्क्रिप्ट करने के लिए एक पासवर्ड पूछेगा। (मैं समझाऊंगा कि उस पास का उपयोग कैसे करें)

और फिर आप अपने चरों का उपयोग कर सकते हैं जहाँ आप चाहते हैं। कोई भी उन्हें तिजोरी-चाबी के बिना नहीं पढ़ सकता है।

वॉल्ट कुंजी का उपयोग:

प्लेबुक चलाते समय पासिंग तर्क के माध्यम से।

--ask-vault-pass: secret

या आप पासवर्ड की तरह फ़ाइल में सहेज सकते हैं। (CI उपयोगकर्ताओं के लिए उपयोगी)

--vault-password-file=/path/to/file.txt

आपके मामले में: vars yml शामिल करें और अपने चर का उपयोग करें।

- include_vars: /path/credential.yml

  - name: Add deployment user
    action: user name={{user.name}} password={{user.pass}}
— pmoksuz
स्रोत
मैंने ठीक यही कोशिश की है, और यह काम नहीं करता है। मुझे विश्वास है, यह इसलिए है क्योंकि password={{user.pass}}वास्तविक पासवर्ड को शामिल करने के लिए विस्तार होगा, जबकि ansible को हैश की उम्मीद है।
— टेक्निक
2

उपयोगकर्ता के लिए यादृच्छिक पासवर्ड जनरेट करना

पहले उपयोगकर्ताओं को परिभाषित करने की आवश्यकता है चर फिर नीचे का पालन करें

कार्य:

- name: Generate Passwords
  become: no
  local_action: command pwgen -N 1 8
  with_items: '{{ users }}'
  register: user_passwords

- name: Update User Passwords
  user:
    name: '{{ item.item }}'
    password: "{{ item.stdout | password_hash('sha512')}}"
    update_password: on_create
  with_items: '{{ user_passwords.results }}'

- name: Save Passwords Locally
  become: no
  local_action: copy content={{ item.stdout }} dest=./{{ item.item }}.txt
  with_items: '{{ user_passwords.results }}'
— अपूरी श्रीकांत
स्रोत
1

Mxx का उत्तर सही है लेकिन आप अजगर crypt.crypt()विधि सुरक्षित नहीं है जब विभिन्न ऑपरेटिंग सिस्टम शामिल होते हैं (आपके सिस्टम पर उपयोग किए गए glibc हैश एल्गोरिथम से संबंधित)।

उदाहरण के लिए, यदि आपका MacOS से हैश उत्पन्न करता है और लिनक्स पर एक प्लेबुक चलाता है तो यह काम नहीं करेगा। ऐसे मामले में, आप पासलिब ( pip install passlibस्थानीय रूप से स्थापित करने के लिए) का उपयोग कर सकते हैं ।

from passlib.hash import md5_crypt
python -c 'import crypt; print md5_crypt.encrypt("This is my Password,salt="SomeSalt")'
'$1$SomeSalt$UqddPX3r4kH3UL5jq5/ZI.'
— जोएल बी
स्रोत
1

न तो समाधानों ने सीधे मेरे मैक पर उबंटू को नियंत्रित करने का काम किया। तो दूसरों के लिए, Mxx और JoelB के उत्तर को मिलाकर, यहाँ वर्तमान पायथन 3 समाधान है:

pip3 install passlib

python3 -c 'from passlib.hash import md5_crypt; \
      print(md5_crypt.encrypt("This is my Password", salt="SomeSalt"))'

परिणाम होगा $1$SomeSalt$UqddPX3r4kH3UL5jq5/ZI., जैसा कि XXX के उत्तर में है।

बेहतर अभी भी , MD5 के बजाय SHA512 का उपयोग करें:

python3 -c 'from passlib.hash import sha512_crypt; \
      print(sha512_crypt.encrypt("This is my Password", salt="SomeSalt"))'

परिणाम:

$ 6 $ राउंड = 656.000 $ SomeSalt $ oYpmnpZahIsvn5FK8g4bDFEAmGpEN114Fe6Ko4HvinzFaz5Rq2UXQxoJZ9ZQyQoi9zaBo3gBH / FEAov3FHv48

— texnic
स्रोत
1

मैंने एक ansible-playbook बनाई है जो आपको एक linux account बनाने की अनुमति देता है जो पासवर्ड प्रमाणीकरण की अनुमति देता है।

CreateLinuxAccountWithAnsible देखें ।

mkpasswdकमांड का उपयोग करके हैशेड पासवर्ड उत्पन्न होता है । मैंने mkpasswdविभिन्न ऑपरेटिंग सिस्टम पर स्थापित करने के तरीके प्रदान किए हैं।

यहाँ मेरी स्क्रिप्ट का उपयोग करने के लिए आवश्यक कदम हैं:

  1. बदलें <your_user_name>और अपने वांछित उपयोगकर्ता नाम और पासवर्ड के साथ <your_password>अंदर run.sh।

  2. कनेक्शन की जानकारी बदलें inventoryताकि उपयोगकर्ता बनाने के लिए ansible मशीन से जुड़ सके।

  3. ./run.shस्क्रिप्ट निष्पादित करने के लिए चलाएँ ।

— ब्रायन
स्रोत
1
फ़ाइल अब GitHub पर नहीं है।
— Janus
0

यदि आप इसे एक ऐसिबल एड-हॉक कमांड के रूप में पूरा करना चाहते हैं, तो आप निम्न कार्य कर सकते हैं:

$ password='SomethingSecret!'
$ ansible 192.168.1.10 -i some_inventory -b -m user -a "name=joe_user \
       update_password=always password=\"{{ \"$password\" | password_hash('sha512') }}\""

उपरोक्त आदेश से आउटपुट:

192.168.1.10 | SUCCESS => {
    "append": false,
    "changed": true,
    "comment": "Joe User",
    "group": 999,
    "home": "/home/joe_user",
    "move_home": false,
    "name": "joe_user",
    "password": "NOT_LOGGING_PASSWORD",
    "shell": "/bin/bash",
    "state": "present",
    "uid": 999
}
— SLM
स्रोत
0

मुझे पता है कि मुझे पार्टी में देर हो रही है, लेकिन एक और समाधान है जिसका मैं उपयोग कर रहा हूं। यह उन विकृतियों के लिए उपयोगी हो सकता है --stdinजो पासवार्ड बाइनरी में नहीं हैं ।

- hosts: localhost
  become: True
  tasks:
    - name: Change user password
      shell: "yes '{{ item.pass }}' | passwd {{ item.user }}"
      loop:
       - { pass: 123123, user: foo }
       - { pass: asdf, user: bar }
      loop_control:
        label: "{{ item.user }}"

लेबल केवल उपयोगकर्ता नाम loop_controlप्रिंट करने के लिए जिम्मेदार है । पूरी प्लेबुक या केवल उपयोगकर्ता चर (आप उपयोग कर सकते हैं ) को एनसिबल-वॉल्ट के साथ एन्क्रिप्ट किया जाना चाहिए।vars_files:

— एलेक्स बारानोव्स्की
स्रोत
0

मेरा समाधान लुकअप का उपयोग कर रहा है और स्वचालित रूप से पासवर्ड जनरेट करता है।

---
- hosts: 'all'
  remote_user: root
  gather_facts: no
  vars:
    deploy_user: deploy
    deploy_password: "{{ lookup('password', '/tmp/password chars=ascii_letters') }}"

  tasks:
    - name: Create deploy user
      user:
        name: "{{ deploy_user }}"
        password: "{{ deploy_password | password_hash('sha512') }}"
— एलेक्स नौमोव
स्रोत
0

Mkpasswd, Python आदि सहित कई उपयोगिताओं की कोशिश की, लेकिन ऐसा लगता है कि अन्य उपकरणों द्वारा उत्पन्न एचएएसएच मूल्यों को पढ़ने में Ansible के साथ कुछ संगतता मुद्दा है। तो अंत में यह ansible # मान से ही काम किया।

ansible all -i localhost; -m debug -a "msg = {'yourpasswd'।: password_hash ('sha512', 'mysecretsalt')}}"

प्लेबुक -

- name: User creation
  user: 
    name: username  
    uid: UID
    group: grpname
    shell: /bin/bash
    comment: "test user"
    password: "$6$mysecretsalt$1SMjoVXjYf.3sJR3a1WUxlDCmdJwC613.SUD4DOf40ASDFASJHASDFCDDDWERWEYbs8G00NHmOg29E0"
— DjangoChained
स्रोत
-1

अच्छी तरह से मैं पार्टी करने के लिए पूरी तरह से देर से आया हूँ :) मुझे एक अनम्य नाटक की आवश्यकता थी जो कई स्थानीय उपयोगकर्ताओं को रैंडम पासवर्ड के साथ बनाता है। यह मेरे साथ आया था, ऊपर से कुछ उदाहरणों का इस्तेमाल किया और उन्हें कुछ परिवर्तनों के साथ रखा।

create-उपयोगकर्ता के साथ-password.yml

---
# create_user playbook

- hosts: all
  become: True
  user: root
  vars:
#Create following user
   users:
    - test24
    - test25
#with group
   group: wheel
  roles:
    - create-user-with-password

/roles/create-user-with-password/tasks/main.yml

- name: Generate password for new user
  local_action: shell pwgen -s -N 1 20
  register: user_password
  with_items: "{{ users }}"
  run_once: true

- name: Generate encrypted password
  local_action: shell python -c 'import crypt; print(crypt.crypt( "{{ item.stdout }}", crypt.mksalt(crypt.METHOD_SHA512)))'
  register: encrypted_user_password
  with_items: "{{ user_password.results }}"
  run_once: true

- name: Create new user with group
  user:
    name: "{{ item }}"
    groups: "{{ group }}"
    shell: /bin/bash
    append: yes
    createhome: yes
    comment: 'Created with ansible'
  with_items:
    - "{{ users }}"
  register: user_created

- name: Update user Passwords
  user:
    name: '{{ item.0 }}'
    password: '{{ item.1.stdout }}'
  with_together:
    - "{{ users }}"
    - "{{ encrypted_user_password.results }}"
  when: user_created.changed

- name: Force user to change the password at first login
  shell: chage -d 0 "{{ item }}"
  with_items:
    - "{{ users }}"
  when: user_created.changed

- name: Save Passwords Locally
  become: no
  local_action: copy content={{ item.stdout }} dest=./{{ item.item }}.txt
  with_items: "{{ user_password.results }}"
  when: user_created.changed
— Juhani
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.