http://feeds.techie-buzz.com/~r/techiebuzz/~3/ejh-SowBlF0/new-super-earth.html
Discovered: The Best Bet Yet For A Super-Earth, And It’s Very Close Too!
Posted: February 5, 2012 in Uncategorized0
From emails I receive it seems like there is a bit of confusion about what the terms 2-legged OAuth and 3-legged OAuth mean. I hope I can clear up this confusion with this article (and don’t contribute more to the confusion…).
In short, they describe two different usage scenarios of OAuth involving two respectively three parties.
3-legged OAuth describes the scenario for which OAuth was originally developed: a resource owner wants to give a client access to a server without sharing his credentials (i.e. username/password). A typical example is a user (resource owner) who wants to give a third-party application (client) access to his Twitter account (server).
On a conceptual level it works in the following way:
Client has signed up to the server and got his client credentials (also known as “consumer key and secret”) ahead of time
User wants to give the client access to his protected resources on the server
Client retrieves the temporary credentials (also known as “request token”) from the server
Client redirects the resource owner to the server
Resource owner grants the client access to his protected resources on the server
Server redirects the user back to the client
Client uses the temporary credentials to retrieve the token credentials (also known as “access token”) from the server
Client uses the token credentials to access the protected resources on the server
2-legged OAuth , on the other hand, describes a typical client-server scenario, without any user involvement. An example for such a scenario could be a local Twitter client application accessing your Twitter account.
On a conceptual level 2-legged OAuth simply consists of the first and last steps of 3-legged OAuth:
Client has signed up to the server and got his client credentials (also known as “consumer key and secret”)
Client uses his client credentials (and empty token credentials) to access the protected resources on the server
Above I used Twitter as an example, though strictly speaking, they don’t use 2-legged OAuth, but a variant of it. They not only provide the client credentials but also the token credentials (see also Using one access token with OAuth ).
As you have seen, 2-legged OAuth is nothing new, it is simply using OAuth in a different scenario than it was designed for. And hence you can use (almost?) all existing OAuth libraries for 2-legged OAuth, too.
Nuance launches Dragon Go! for Android, available today for free
Posted: January 10, 2012 in UncategorizedLast week, we learned that a fully loaded Amazon Kindle weighs more than a brand new, unused and empty one. This week’s revelation on the same theme is that the internet, in all its infinite glory, weighs about the same as a strawberry. Confused? Excellent.
The internet.
Professor John Kubiatowicz, of the University of California, Berkeley, explained his observation about the Kindle last week, drawing on Einstein’s E=mc² equation, which establishes mass and energy equivalence. He noted that a Kindle stores data by trapping electrons; when a book is downloaded to the Kindle, the number of electrons stays the same, but the energy needed to store the data increases.
As the electrons gain energy, they gain mass, as Einstein’s equation tells us. Armed with this knowledge, the Professor calculated that a fully-loaded 4GB Kindle would weigh a billionth of a billionth of a gram (also known as one attogram, 1ag or 0.000000000000000001g) more than a brand new one.
Building on this further, the clever chaps at YouTube channel vsauce have thrown together a bunch of calculations, that boil down to their conclusion that the internet in its entirety – that’s all of the electrons on all of the servers in all nations across the globe – is made up of a sum total of 50 grams of electrons in motion.
Rather than tax my simple, feeble mind by trying to explain this to you further – the blind leading the blind will get no-one anywhere fast here – check out the video below for an easy-to-digest explanation of Professor Kubiatowicz’s and vsauce’s calculations.
So there we have it: the internet is roughly equivalent in weight to a strawberry. There’s definitely a joke to be made about internet traffic jams here, but perhaps it’s best to avoid that temptation.
Image source: Thundafunda
Google OpenID Authentication In Your ASP.NET With DotNetOpenAuth
Posted: December 19, 2011 in UncategorizedTags: Google, socal coding
To secure websites, we usually create user database and develop a login page to authenticate the user. If you have several websites, creating separate user login for each site is time consuming and not favorable to your users because they have to login to each site separately. OpenID was developed to solved such authentication hassles. It is an open standard for developers that enables them to authenticate their users in a decentralized manner. For end-users, OpenID allows them to consolidate their digital identities. Major web services that supports OpenID are Google, Yahoo and Facebook. If you use OpenID with your website, you allow users to login to your site using their Google, Yahoo or Facebook accounts. The authentication will be hosted by the OpenID provider, so no need to maintain the user details on your side except the Identifier returned by the provider.On this article, I will show you a ASP.NET sample code I made that use OpenID Authentication to verify Google Account. To accomplish the authentication, I used the C# library called DotNetOpenAuth. Here is the step-by-step procedure to implement it on your ASP.NET application.
- Download the DotNetOpenAuth Libraries. Choose the most appropriate version for development platform.
- Extract the downloaded compressed file on your hard drive.
- On your project, Add Reference to “DotNetOpenAuth.dll”
- On your login page’s HTML Code, paste the following.
| <form id=”form1″ runat=”server”> <div id=”loginform”> <div id=”NotLoggedIn” runat=”server”> Log in with <img src=”http://www.google.com/favicon.ico” /> <asp:Button ID=”btnLoginToGoogle” Runat=”server” Text=”Google” OnCommand=”OpenLogin_Click” CommandArgument=”https://www.google.com/accounts/o8/id” /> <asp:Label runat=”server” ID=”lblAlertMsg” /> </div> </div> </form> |
Take note of the URL: https://www.google.com/accounts/o8/id – this is the unique OpenID URL of Google Account. 5. Include the following namespaces on your “Using” directive.
6. On the Page_Load & OpenLogin_Click, use the following codes
| using DotNetOpenAuth.OpenId; using DotNetOpenAuth.OpenId.RelyingParty; |
| protected void Page_Load(object sender, EventArgs e) { OpenIdRelyingParty rp = new OpenIdRelyingParty(); var r = rp.GetResponse(); if (r != null) { switch (r.Status) { case AuthenticationStatus.Authenticated: NotLoggedIn.Visible = false; Session["GoogleIdentifier"] = r.ClaimedIdentifier.ToString(); Response.Redirect(“Main.aspx”); //redirect to main page of your website break; case AuthenticationStatus.Canceled: lblAlertMsg.Text = “Cancelled.”; break; case AuthenticationStatus.Failed: lblAlertMsg.Text = “Login Failed.”; break; } } }protected void OpenLogin_Click(object src, CommandEventArgs e) { string discoveryUri = e.CommandArgument.ToString(); OpenIdRelyingParty openid = new OpenIdRelyingParty(); var b = new UriBuilder(Request.Url) { Query = “” }; var req = openid.CreateRequest(discoveryUri, b.Uri, b.Uri); req.RedirectToProvider(); } |
7. Run the project. It should look like the following screens.
Log in with Now the Login page look like ….
