I created a brand new github account and then a new repository.
Also, I created a github token.
Locally on my mac, I run a
git push
and the first time I had to enter username and github-token.
After that, it seems terminal never asks for username or password/token.
Then I logged in into my ec2 server and did the same:
git clone myrepo
username: my_username
passowrd: my_token
And I was able to get the code.
After that, each time I make a pull in my ec2 server, it always prompts for username/password.
So for some reason mac stores credentials but aws doesn't.
It seems you need some application?
I had a look at this:
https://docs.github.com/en/get-started/getting-started-with-git/caching-your-github-credentials-in-git
But it seems there is no available version for my ec2? What I understand it uses its own linux distro, called Amazon Linux 2. So the question is: is there a credential manager for aws ec2?
Have you following the instruction?
Link: https://github.com/GitCredentialManager/git-credential-manager/blob/main/docs/credstores.md#gits-built-in-credential-cache
Git's built-in credential cache
Available on: Windows, macOS, Linux
export GCM_CREDENTIAL_STORE=cache
# or
git config --global credential.credentialStore cache
This credential store uses Git's built-in ephemeral in-memory
credential cache. This helps you reduce the number of times you have
to authenticate but doesn't require storing credentials on persistent
storage. It's good for scenarios like Azure Cloud Shell or AWS
CloudShell, where you don't want to leave credentials on disk but also
don't want to re-authenticate on every Git operation.
By default, git credential-cache stores your credentials for 900
seconds. That, and any other options it accepts, may be altered by
setting them in the environment variable GCM_CREDENTIAL_CACHE_OPTIONS
or the Git config value credential.cacheOptions. (Using the --socket
option is untested and unsupported, but there's no reason it shouldn't
work.)
export GCM_CREDENTIAL_CACHE_OPTIONS="--timeout 300"
# or
git config --global credential.cacheOptions "--timeout 300"
Related
I have tried to check several SO questions and answers but still unable to resolve my concern. The scenario is this:
User A with Git Account A git cloned repo to freshly installed server.
Because of this, the git account that was registered on the server was User A.
(If I understood it correctly. please correct me if I am wrong in this part)
Now I would like to use User B with Git Account B as commiter/puller/pusher to the server.
What I tried was to change the user and email with the following command:
git config --global user.name "userb"
git config --global user.email "userb#gmail.com"
git config --local user.name "userb"
git config --local user.email "userb#gmail.com"
git config user.name "userb"
git config user.email "userb#gmail.com"
On 3 separate occasions. Still unable to resolve my concern. I can see the updated user and email with command git config --list, git config user.name and git config user.email so I know that the value did change.
If this is not possible, I am also considering to remove the accounts all together and enter the user/email and password when pulling/pushing without removing the git history.
You are doing the wrong thing. You are trying to change the user name used to mark your commits, instead you have to reset your git user account credentials.
Under Linux issue git config --unset credential.helper, under Windows remove the credentials by the Windows Credentials Manager.
User A with Git Account A git cloned repo to freshly installed server.
Because of this, the git account that was registered on the server was User A.
No. There are two common / standard transport mechanisms that a Git client (like git clone) will use to talk to a Git server:
https: the client provides a user name and additional authentication data (password, token, whatever); or
ssh: the client provides a public key; the server looks up the public key to determine who the client claims to be,1 and challenges the client with a task that can only be completed by someone holding the corresponding private key, so that if the client does complete the task, the claim must have been accurate.
These mechanisms are provided not by Git itself, but by some sort of access wrapper: a web server, or an sshd.
At this point, the client is authenticated to the server, and only now does Git itself actually enter the picture. The server's Git software hands to the client every commit in the server's repository (so that the client has all the commits), and shows to the client all the branch names (which the client then changes into remote-tracking names, so that the client has all the commits and no branches at all). Then the client disconnects from the server, creates one branch in the new Git repository, and is done.
The only thing retained here is the URL that the client used to reach the server. This URL is retained in the Git repository the client just created. Unless the server keeps logs (via its web server and/or sshd),2 the server now has no record at all of the client.
The next time the client needs to talk to the server, the client provides the URL, which it has saved conveniently under the short name origin.3 This URL may contain a user name, especially if you used an https:// URL.
So: check the URL, using git remote -v, to find out which protocol you are using and whether, if that protocol is https://, there is a user name embedded in the URL. If so, you can edit or remove that user name. If not, and the URL is an https:// URL, proceed with Antonio Petricca's answer. If the URL is an ssh:// one, look into ssh authentication.
1On some servers, the user logs in using their own account, but for the usual GitHub, GitLab, and Bitbucket setups, the user provides the generic user name git. Hence the server has to use this public-key trick to figure out who the user is claiming to be.
2Most servers do keep logs, but that's up to the server, and they're used at most for auditing and security. It does not affect future attempts to connect to the server, unless, e.g., the people running the server find your connection alarming and block it.
3You can choose some other name, but there is no reason to do that, and presumably you did not.
I am self hosting Gitlab, and added force reCaptcha to login/register.
I accidentally entered a v3 key and not a v2 key and now I can't log in because it shows:
ERROR for site owner: Invalid key type.
Any idea on how to change it manually in the files?
I am running Ubuntu Desktop 18.04.4
I did the same mistake and was mistaken ReCaptcha v2 with v3. I was completely locked out and didn't have the personal access token.
This solution worked for me as well. However, I would not recommend doing it so, if you are not familiar with Postgres or even GitLab's configuration, you don't know if other auditing actions are intercepting once you updated the configuration in the admin panel and you might break something else.
This solution is just updating GitLab's application setting via gitlabhq_production database. The following steps work in my case having the Omnibus package installation method used. I assume it should not be much different if you have direct access to the database.
gitlab-psql -d gitlabhq_production # login to GitLab's database
UPDATE application_settings SET login_recaptcha_protection_enabled = 'f'; # to disable login with recaptcha check
gitlab-ctl reconfigure # to reconfigure Gitlab instance or restart your Gitlab instance.
If you can connect to the GItLab server, you could, as noted in gitlab-org/gitlab-foss issue 46548
disable reCAPTCHA in the admin settings (admin/application_settings/reporting)
Once disable, you can at least log on, and re-enable the feature, this time entering a v2 key.
Another possibility, which I used:
If you're able to gain access via a previously generated (and saved) GitLab ReST API - PERSONAL ACCESS TOKEN (created with All Scopes / Full Admin privileges), then you can use that token to update your reCAPTCHA keys via the following CLI command:
user$ curl --request PUT --header \
"PRIVATE-TOKEN: <PersonalAccessToken>" \
"https://gitlab.example.com/api/v4/application/settings?recaptcha_private_key=<SecretKey>&recaptcha_site_key=<SiteKey>"
I hope this helps others.
I would like to store Git credentials for git pulls permenantly on a linux machine, and git credential.helper doesn't work ( I think because I'm not using SSH ) - I get that error "Fatal: could not read password for 'http://....': No such device or address". Given that I'm not the administrator of the repository and only HTTP is allowed for authentication, and fortunately I don't care about the safety of the password. What can I do to put the git pull command in a bash file and avoid prompting the user for password?
I hope there is a way around it.
Two things wrong with this question:
Most repositories such as GitHub require HTTPS. Even if you try to clone over
HTTP, it just switches it on the backend to HTTPS and pushes require it as
well.
Pulls don’t require a password, unless it’s a private repo. Like #1, since
you’ve given no info about your repo it’s hard to comment further on this.
Now, what I do is this:
git config --global credential.helper store
Then the first time you push it will ask for your credentials. Once you’ve
entered them they are stored in ~/.git-credentials. Note that they are stored
in plain text, you have been advised.
I'm assuming that your repository requires authentication for pulls, or else git wouldn't ask you for a password for the pull.
The recommended way to bypass the user password prompt is to create an SSH key on that machine, add the public key to the git server, then use the SSH url for the remote instead of the HTTP/S url. But since you specifically said:
I don't care about the safety of the password
you can actually just specify the password inline for the git pull like this:
git pull http://username:password#mygithost.com/my/repository
I am trying to setup my git workflow (to deploy automatically my node.js app when I push).
I have tried multiple things and end up doing this : http://toroid.org/ams/git-website-howto
I managed to make this method work but I have one problem left :
I am in the list of authorized_keys of my git and root users so I can login via SSH to these users.
But when I do a git pull, my computer tries to ssh using its current user to the server. That means that it searches on my server a user which has the same login as my local one (which doesn't exist)
If I am logged locally as root, it connect as root to the distant server and works. Otherwise, it tries a user that doesn't exist there and doesn't work.
Not sure if I explained this well... Sorry if this is not. Anyway if anyone know how to fix this and make me able to use git without having to create a distant user for each people of my team it would be cool :)
Oh and my client is OS X and server Ubuntu
I’m not entirely sure if I understood you correctly, but you can set the username directly when specifying the URL of the remote.
For example on most Git hosting sites, you are supposed to use the user git when connecting via SSH. This allows them to create only a single user they have to maintain while putting all authorization details behind that.
So a usual remote URL on GitHub for example looks like this: git#github.com:user/repository. This is the long form of ssh://git#github.com/user/repository.
So when you set your remote, when cloning, or afterwards, just include your username there and Git will use it when connecting via SSH:
git clone git#myserver:/path/to/repository
I have the following setup:
A server (centOS) with git and a repository for a project on the same server.
What I need to do is to be able to pull from the repository without being asked for password (because is annoying).
Note: I am logged as root when I pull.
Can anyone help me with that?
There are a few options, depending on what your requirements are, in particular your security needs. For both HTTP and SSH, there is password-less, or password required access.
HTTP
==============
Password-Less
Useful for fetch only requirements, by default push is disabled. Perfect if anonymous cloning is the intention. You definitely shouldn't enable push for this type of configuration. The man page for git-http-backend contains good information, online copy at http://www.kernel.org/pub/software/scm/git/docs/git-http-backend.html. It provides an example of how to configure apache to provide this.
User/password in .netrc or url embedded
Where .netrc files are using in the form:
machine <hostname> login <username> password <password>
And embedded urls would be in the form:
http://user:pass#hostname/repo
Since git won't do auth for you, you will need to configure a webserver such as apache to perform the auth, before passing the request onto the git tools. Also keep in mind that using the embedded method is a security risk, even if you use https since it is part of the url being requested.
If you want to be able to pull non-interactive, but prevent anonymous users from accessing the git repo, this should be a reasonably lightweight solution using apache for basic auth and preferably the .netrc file to store credentials. As a small gotcha, git will enable write access once authentication is being used, so either use anonymous http for read-only, or you'll need to perform some additional configuration if you want to prevent the non-interactive user from having write access.
See:
httpd.apache.org/docs/2.4/mod/mod_auth_basic.html for more on configuring basic auth
www.kernel.org/pub/software/scm/git/docs/git-http-backend.html for some examples on the apache config needed.
SSH
==============
Passphrase-Less
Opens up for security issues, since anyone who can get a hold of the ssh private key can now update the remote git repo as this user. If you want to use this non-interactively, I'd recommend installing something like gitolite to make it a little easier to ensure that those with the ssh private key can only pull from the repo, and it requires a different ssh key pair to update the repo.
See github.com/sitaramc/gitolite/ for more on gitolite.
stromberg.dnsalias.org/~strombrg/ssh-keys.html - for creating password less ssh keys:
May also want to cover managing multiple ssh keys: www.kelvinwong.ca/2011/03/30/multiple-ssh-private-keys-identityfile/
Passphase protected
Can use ssh-agent to unlock on a per-session basis, only really useful for interactive fetching from git. Since you mention root and only talk about performing 'git pull', it sounds like your use case is non-interactive. This is something that might be better combined with gitolite (github.com/sitaramc/gitolite/).
Summary
==============
Using something like gitolite will abstract a lot of the configuration away for SSH type set ups, and is definitely recommended if you think you might have additional repositories or need to specify different levels of access. It's logging and auditing are also very useful.
If you just want to be able to pull via http, the git-http-backend man page should contain enough information to configure apache to do the needful.
You can always combine anonymous http(s) for clone/pull, with passphrase protected ssh access required for full access, in which case there is no need to set up gitolite, you'll just add the ssh public key to the ~/.ssh/authorized_keys file.
See the answer to this question. You should use the SSH access instead of HTTPS/GIT and authenticate via your SSH public key. This should also work locally.
If you're using ssh access, you should have ssh agent running, add your key there and register your public ssh key on the repo end. Your ssh key would then be used automatically. This is the preferred way.
If you're using https access, you one would either
use a .netrc file that contains the credentials or
provide user/pass in the target url in the form https://user:pass#domain.tld/repo
With any of these three ways, it shouldn't ask for a password.